// Package event define real time data evnet operation functions
package event

import (
	"context"
	"encoding/json"

	"modelRT/logger"
	"modelRT/mq"
)

type actionHandler func(ctx context.Context, content string, ops ...EventOption) error

// actionDispatchMap define variable to store all action handler into map
var actionDispatchMap = map[string]actionHandler{
	"info":      handleInfoAction,
	"warning":   handleWarningAction,
	"error":     handleErrorAction,
	"critical":  handleCriticalAction,
	"exception": handleExceptionAction,
}

// TriggerEventAction define func to trigger event by action in compute config
func TriggerEventAction(ctx context.Context, command string, eventName string, ops ...EventOption) {
	handler, exists := actionDispatchMap[command]
	if !exists {
		logger.Error(ctx, "unknown action command", "command", command)
		return
	}
	err := handler(ctx, eventName, ops...)
	if err != nil {
		logger.Error(ctx, "action handler failed", "command", command, "event_name", eventName, "error", err)
		return
	}
	logger.Info(ctx, "action handler success", "command", command, "event_name", eventName)
}

func handleInfoAction(ctx context.Context, eventName string, ops ...EventOption) error {
	eventRecord, err := NewGeneralPlatformSoftRecord(eventName, ops...)
	if err != nil {
		logger.Error(ctx, "generate info event record failed", "error", err)
		return err
	}
	recordBytes, err := json.Marshal(eventRecord)
	if err != nil {
		logger.Error(ctx, "marshal event record failed", "event_uuid", eventRecord.EventUUID, "error", err)
		return err
	}
	mq.MsgChan <- recordBytes
	logger.Info(ctx, "trigger info event", "event_name", eventName)
	return nil
}

func handleWarningAction(ctx context.Context, eventName string, ops ...EventOption) error {
	eventRecord, err := NewWarnPlatformSoftRecord(eventName, ops...)
	if err != nil {
		logger.Error(ctx, "generate warning event record failed", "error", err)
		return err
	}
	recordBytes, err := json.Marshal(eventRecord)
	if err != nil {
		logger.Error(ctx, "marshal event record failed", "event_uuid", eventRecord.EventUUID, "error", err)
		return err
	}
	mq.MsgChan <- recordBytes
	logger.Info(ctx, "trigger warning event", "event_name", eventName)
	return nil
}

func handleErrorAction(ctx context.Context, eventName string, ops ...EventOption) error {
	eventRecord, err := NewCriticalPlatformSoftRecord(eventName, ops...)
	if err != nil {
		logger.Error(ctx, "generate error event record failed", "error", err)
		return err
	}
	recordBytes, err := json.Marshal(eventRecord)
	if err != nil {
		logger.Error(ctx, "marshal event record failed", "event_uuid", eventRecord.EventUUID, "error", err)
		return err
	}
	mq.MsgChan <- recordBytes
	return nil
}

func handleCriticalAction(ctx context.Context, content string, ops ...EventOption) error {
	// 实际执行发送警告、记录日志等操作
	actionParams := content
	// ... logic to send critical level event using actionParams ...
	logger.Warn(ctx, "trigger critical event", "message", actionParams)
	return nil
}

func handleExceptionAction(ctx context.Context, content string, ops ...EventOption) error {
	// 实际执行发送警告、记录日志等操作
	actionParams := content
	// ... logic to send except level event using actionParams ...
	logger.Warn(ctx, "trigger except event", "message", actionParams)
	return nil
}