package worker

import (
	"context"
	"encoding/json"
	"errors"
	"kra/internal/biz/business"
	"kra/internal/biz/system"
	taskbiz "kra/internal/biz/task"

	"kra/internal/config"
	taskmodule "kra/internal/modules/task"
	platformtask "kra/pkg/task"
)

// TaskMethods owns the dependency-bearing built-in task handlers.
type TaskMethods struct {
	tasks         *taskbiz.TaskUsecase
	maintenance   *system.MaintenanceUsecase
	media         *system.MediaUsecase
	runtime       *config.Store
	reports       *business.ReportBuildUsecase
	alerts        *business.AlertTriggerUsecase
	effectiveness *business.EffectivenessUsecase
}

func NewTaskMethods(tasks *taskbiz.TaskUsecase, maintenance *system.MaintenanceUsecase, media *system.MediaUsecase, runtime *config.Store, reports *business.ReportBuildUsecase, alerts *business.AlertTriggerUsecase, effectiveness *business.EffectivenessUsecase) *TaskMethods {
	return &TaskMethods{tasks: tasks, maintenance: maintenance, media: media, runtime: runtime, reports: reports, alerts: alerts, effectiveness: effectiveness}
}

func (methods *TaskMethods) RegisterTasks(registry *platformtask.Registry) {
	if methods == nil || registry == nil {
		return
	}
	methods.registerBusinessReports(registry)
	for _, job := range []struct {
		name, description string
		full              bool
	}{{"channelEffectivenessTask", "增量刷新渠道有效端", false}, {"channelEffectivenessFullTask", "全量核对有效端，补齐延迟到达的历史流水", true}} {
		registry.Register(platformtask.Method{Name: job.name, Description: job.description, Run: func(ctx context.Context, params json.RawMessage) error {
			if methods.effectiveness == nil {
				return errors.New("有效端任务依赖未就绪")
			}
			if ctx == nil {
				ctx = context.Background()
			}
			var args struct {
				Full bool `json:"full"`
			}
			if len(params) > 0 {
				if err := json.Unmarshal(params, &args); err != nil {
					return err
				}
			}
			return methods.effectiveness.Refresh(ctx, job.full || args.Full)
		}})
	}
	registry.Register(platformtask.Method{Name: "alertTriggerTask", Description: "按商务范围检测并生成预警", Run: func(ctx context.Context, _ json.RawMessage) error {
		if methods.alerts == nil {
			return errors.New("预警任务依赖未就绪")
		}
		if ctx == nil {
			ctx = context.Background()
		}
		return methods.alerts.Run(ctx)
	}})
	descriptions := map[string]string{}
	for _, task := range taskmodule.TimedTasks() {
		descriptions[task.MethodName] = task.Description
	}
	registry.Register(platformtask.Method{
		Name: taskbiz.TaskMethodClearDB, Description: descriptions[taskbiz.TaskMethodClearDB], Run: func(ctx context.Context, _ json.RawMessage) error {
			if ctx == nil {
				ctx = context.Background()
			}
			if methods.maintenance == nil || methods.tasks == nil {
				return errors.New("ClearDB 任务依赖未就绪")
			}
			if err := methods.maintenance.CleanupExpired(ctx); err != nil {
				return err
			}
			return methods.tasks.CleanupTaskLogs(ctx)
		},
	})
	registry.Register(platformtask.Method{
		Name: taskbiz.TaskMethodUploads, Description: descriptions[taskbiz.TaskMethodUploads], Run: func(ctx context.Context, _ json.RawMessage) error {
			if ctx == nil {
				ctx = context.Background()
			}
			if methods.media == nil {
				return errors.New("CleanStaleUploads 任务依赖未就绪")
			}
			ttl := 24
			var admin *config.Admin
			if methods.runtime != nil {
				if snapshot := methods.runtime.Snapshot(); snapshot != nil {
					admin = snapshot.Admin
				}
			}
			if admin != nil && admin.Media != nil && admin.Media.SessionTTL > 0 {
				ttl = admin.Media.SessionTTL
			}
			return methods.media.CleanupStale(ctx, ttl)
		},
	})
}