package worker

import (
	"context"
	"encoding/json"
	"fmt"
	"sync"

	"git.lastassault.de/speatzle/morffix/constants"
	"git.lastassault.de/speatzle/morffix/rpc"
	"git.lastassault.de/speatzle/morffix/task"
	"git.lastassault.de/speatzle/morffix/types"
)

var tasks map[int]*task.Task
var taskMutex sync.Mutex

func init() {
	rpcServer.RegisterMethod("task-start", taskStart)
	rpcServer.RegisterMethod("task-status", taskStatus)
}

func taskStart(ctx context.Context, req rpc.Request) (any, error) {
	var data types.TaskStart
	err := json.Unmarshal(*req.Params, &data)
	if err != nil {
		return nil, fmt.Errorf("Unmarshal Task Start Params: %w", err)
	}

	// TODO move to task module
	taskMutex.Lock()
	defer taskMutex.Unlock()

	switch data.Type {
	case constants.TASK_TYPE_HEALTHCHECK:
		tasks[data.ID] = &task.Task{
			ID:     data.ID,
			Type:   data.Type,
			FileID: data.FileID,
		}

		var hData task.HealthCheckData
		err := json.Unmarshal(data.Data, &hData)
		if err != nil {
			return nil, fmt.Errorf("Unmarshal Healthcheck Data: %w", err)
		}

		tasks[data.ID].Status = constants.TASK_STATUS_RUNNING
		go tasks[data.ID].RunHealthCheck(hData)
	case constants.TASK_TYPE_TRANSCODE:
		return nil, fmt.Errorf("Transcode Task Not Implemented")
	default:
		return nil, fmt.Errorf("Unknown Task Type %v", data.Type)
	}

	return nil, nil
}

func taskStatus(ctx context.Context, req rpc.Request) (any, error) {
	var id int
	err := json.Unmarshal(*req.Params, &id)
	if err != nil {
		return nil, fmt.Errorf("Unmarshal Task Status Params: %w", err)
	}
	return nil, nil
}