package queue

import (
	"github.com/hibiken/asynq"
	"github.com/redis/go-redis/v9"
	"go.uber.org/zap"
	"gorm.io/gorm"

	"github.com/break/junhong_cmp_fiber/internal/store/postgres"
	"github.com/break/junhong_cmp_fiber/internal/task"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/break/junhong_cmp_fiber/pkg/storage"
)

type Handler struct {
	mux     *asynq.ServeMux
	logger  *zap.Logger
	db      *gorm.DB
	redis   *redis.Client
	storage *storage.Service
}

func NewHandler(db *gorm.DB, redis *redis.Client, storageSvc *storage.Service, logger *zap.Logger) *Handler {
	return &Handler{
		mux:     asynq.NewServeMux(),
		logger:  logger,
		db:      db,
		redis:   redis,
		storage: storageSvc,
	}
}

// RegisterHandlers 注册所有任务处理器
func (h *Handler) RegisterHandlers() *asynq.ServeMux {
	emailHandler := task.NewEmailHandler(h.redis, h.logger)
	syncHandler := task.NewSyncHandler(h.db, h.logger)
	simHandler := task.NewSIMHandler(h.db, h.redis, h.logger)

	h.mux.HandleFunc(constants.TaskTypeEmailSend, emailHandler.HandleEmailSend)
	h.logger.Info("注册邮件发送任务处理器", zap.String("task_type", constants.TaskTypeEmailSend))

	h.mux.HandleFunc(constants.TaskTypeDataSync, syncHandler.HandleDataSync)
	h.logger.Info("注册数据同步任务处理器", zap.String("task_type", constants.TaskTypeDataSync))

	h.mux.HandleFunc(constants.TaskTypeSIMStatusSync, simHandler.HandleSIMStatusSync)
	h.logger.Info("注册 SIM 状态同步任务处理器", zap.String("task_type", constants.TaskTypeSIMStatusSync))

	h.registerIotCardImportHandler()

	h.logger.Info("所有任务处理器注册完成")
	return h.mux
}

func (h *Handler) registerIotCardImportHandler() {
	importTaskStore := postgres.NewIotCardImportTaskStore(h.db, h.redis)
	iotCardStore := postgres.NewIotCardStore(h.db, h.redis)
	iotCardImportHandler := task.NewIotCardImportHandler(h.db, h.redis, importTaskStore, iotCardStore, h.storage, h.logger)

	h.mux.HandleFunc(constants.TaskTypeIotCardImport, iotCardImportHandler.HandleIotCardImport)
	h.logger.Info("注册 IoT 卡导入任务处理器", zap.String("task_type", constants.TaskTypeIotCardImport))
}

// GetMux 获取 ServeMux（用于启动 Worker 服务器）
func (h *Handler) GetMux() *asynq.ServeMux {
	return h.mux
}