package tasks

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"reflect"
	"strings"
	"sync"
	"time"

	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/pkg/errors"
	"github.com/robfig/cron/v3"
	"go.opentelemetry.io/otel"
)

// Task 任务结构体 内置任务
type Task struct {
	ID         string        //任务ID
	TaskType   string        //任务类型
	MethodName string        //方法名
	Params     []interface{} //参数
	Explain    string        //任务描述
}

type TaskOptions struct {
	Uid        string
	Payload    []byte
	Expr       *string         // 仅周期任务
	In         *time.Duration  // 仅一次性任务 当前时间的延迟
	At         *time.Time      // 仅一次性任务 指定时间
	Now        *bool           // 仅一次性任务 当前时间
	Replace    bool            // 仅一次性任务 是否替换已存在的任务
	Ctx        context.Context // 仅一次性任务
	MaxRetry   int
	Timeout    int // 限制并发堵塞超时时间
	Concurrent int // 0不限制并发 1限制并发
}
type taskInfo struct {
	entryID int
	option  TaskOptions
	run     bool
}

type Tasks struct {
	cron    *cron.Cron
	lock    sync.Mutex
	taskMap map[string]*taskInfo
}

var (
	instance *Tasks
	once     sync.Once
)

func TasksInstance(ctx context.Context) *Tasks {
	once.Do(func() {
		instance, _ = NewTasks(ctx) // Initialize only once
	})
	return instance
}

// Once 注册一个任务以运行一次。
func (tk *Tasks) Once(ctx context.Context, taskOptions TaskOptions) error {
	// return tk.worker.Once(options...)
	info := &taskInfo{
		entryID: 0,
		option:  taskOptions,
		run:     false,
	}
	spec := ""
	if taskOptions.Expr != nil && *taskOptions.Expr != "" {
		spec = *taskOptions.Expr
	} else if taskOptions.In != nil {
		spec = fmt.Sprintf("@every %s", *taskOptions.In)
	} else if taskOptions.At != nil {
		spec = fmt.Sprintf("@every %s", time.Until(*taskOptions.At).String())
	} else if taskOptions.Now != nil && *taskOptions.Now {
		go func() {
			tk.process(ctx, info)
		}()
		g.Log().Infof(ctx, "Tasks.Once end. info: %+v", info)
		return nil
	} else {
		return errors.New("expr is required")
	}
	tk.lock.Lock()
	tk.taskMap[taskOptions.Uid] = info
	tk.lock.Unlock()
	entryID, _ := tk.cron.AddFunc(spec, func() {
		tk.process(ctx, info)
		tk.lock.Lock()
		delete(tk.taskMap, taskOptions.Uid)
		tk.lock.Unlock()
	})
	tk.lock.Lock()
	info, ok := tk.taskMap[taskOptions.Uid]
	if ok {
		info.entryID = int(entryID)
	}
	tk.lock.Unlock()
	g.Log().Infof(ctx, "Tasks.Once end. info: %+v", info)
	return nil
}

// 注册一个任务以由cron表达式运行。
func (tk *Tasks) Cron(ctx context.Context, taskOptions TaskOptions) (id string, err error) {
	spec := ""
	if taskOptions.Expr != nil && *taskOptions.Expr != "" {
		spec = *taskOptions.Expr
	} else {
		return "", errors.New("expr is required")
	}
	tk.lock.Lock()
	tk.taskMap[taskOptions.Uid] = &taskInfo{
		entryID: 0,
		option:  taskOptions,
		run:     false,
	}
	tk.lock.Unlock()
	entryID, _ := tk.cron.AddFunc(spec, func() {
		tk.lock.Lock()
		info, ok := tk.taskMap[taskOptions.Uid]
		g.Log().Infof(ctx, "Tasks.Cron AddFunc func begin. uid: %s, spec: %s, ok: %v", taskOptions.Uid, spec, ok)
		if !ok {
			tk.lock.Unlock()
			return
		}
		tk.lock.Unlock()
		start := time.Now()
		for {
			if taskOptions.Timeout > 0 && time.Since(start) > time.Second*time.Duration(taskOptions.Timeout) {
				g.Log().Infof(ctx, "Tasks.Cron AddFunc func timeout. uid: %s, spec: %s, timeout: %d, start: %s", taskOptions.Uid, spec, taskOptions.Timeout, start.Format("2006-01-02 15:04:05"))
				return
			}
			tk.lock.Lock()
			if info.run && info.option.Concurrent == 1 {
				tk.lock.Unlock()
				time.Sleep(time.Second * 1)
				continue
			}
			info.run = true
			tk.lock.Unlock()
			break
		}
		tk.process(ctx, info)
		tk.lock.Lock()
		info.run = false
		tk.lock.Unlock()
	})
	tk.lock.Lock()
	info, ok := tk.taskMap[taskOptions.Uid]
	if ok {
		info.entryID = int(entryID)
	}
	tk.lock.Unlock()
	nextTime := tk.cron.Entry(entryID).Next
	nextTimeStr := nextTime.Format("2006-01-02 15:04:05")
	sub := nextTime.Sub(time.Now())
	g.Log().Infof(ctx, "Tasks.Cron end.	entryID: %d, uid: %s, spec: %s, nextTime:%s, sub:%v", info.entryID, info.option.Uid, spec, nextTimeStr, sub)
	return gconv.String(info.entryID), nil
}

// 从任务队列中删除一个任务。
func (tk *Tasks) Remove(uid string) error {
	tk.lock.Lock()
	info, ok := tk.taskMap[uid]
	if ok {
		tk.cron.Remove(cron.EntryID(info.entryID))
		delete(tk.taskMap, uid)
	}
	tk.lock.Unlock()
	return nil
}

func (tk *Tasks) RemoveCron(entryID string) error {
	tk.lock.Lock()
	for _, info := range tk.taskMap {
		if gconv.String(info.entryID) == entryID {
			tk.cron.Remove(cron.EntryID(info.entryID))
			delete(tk.taskMap, info.option.Uid)
			break
		}
	}
	tk.lock.Unlock()
	return nil
}

func (tk *Tasks) GetTask(uid string) (task *Task, err error) {
	tk.lock.Lock()
	defer tk.lock.Unlock()

	info, ok := tk.taskMap[uid]
	if !ok {
		return nil, errors.New("task not found")
	}

	taskRun := &Task{}

	err = json.Unmarshal(info.option.Payload, &taskRun)
	if err != nil {
		return nil, err
	}
	return taskRun, nil
}

func NewTasks(ctx context.Context) (tk *Tasks, err error) {
	defer func() {
		e := recover()
		if e != nil {
			err = errors.Errorf("%v", e)
		}
	}()
	// logger := &TaskLog{ctx: ctx}
	c := cron.New(cron.WithLocation(time.Local),
		cron.WithSeconds(),
		// cron.WithChain(cron.SkipIfStillRunning(logger)),
	)
	// w := worker.New(
	// 	worker.WithWorkerHandler(func(ctx context.Context, p worker.Payload) error {
	// 		return process(task{
	// 			ctx:     ctx,
	// 			payload: p,
	// 		})
	// 	}),
	// 	worker.WithWorkerRedisPeriodKey("TaskSchedule"),
	// )
	// if w.Error != nil {
	// 	err = errors.WithMessage(w.Error, "initialize worker failed")
	// 	return
	// }
	c.Start()
	tk = &Tasks{
		cron:    c,
		taskMap: make(map[string]*taskInfo),
	}
	g.Log().Debug(ctx, "NewTasks initialize tasks success")
	return
}

func (tk *Tasks) process(ctx context.Context, t *taskInfo) (err error) {
	g.Log().Debug(ctx, "Tasks.process payload", t.option.Payload)
	tr := otel.Tracer("task")
	_, span := tr.Start(ctx, "Task")
	defer span.End()
	var taskRun Task
	err = json.Unmarshal(t.option.Payload, &taskRun)
	if err != nil {
		return err
	}
	g.Log().Debug(ctx, "Tasks.process task", taskRun)
	err = CallMethod(ctx, &taskRun)
	if err != nil {
		fmt.Println("CallMethod err:", err.Error())
		return err
	}
	g.Log().Debug(ctx, "Tasks.process end. task", taskRun)
	return
}

// CallMethod 调用任务的实际方法
func CallMethod(ctx context.Context, task *Task) (err error) {
	// 获取TaskModel的反射值
	taskValue := reflect.ValueOf(task)
	// 准备要调用的方法的参数
	var args []reflect.Value
	for _, param := range task.Params {
		if !reflect.ValueOf(param).IsValid() {
			err = errors.New("invalid parameter")
			return
		}
		args = append(args, reflect.ValueOf(param))
	}
	// 查找并执行方法
	method := taskValue.MethodByName(task.MethodName)
	if method.IsValid() {
		if method.Type().NumIn() == 0 {
			method.Call(nil)
			return
		} else if method.Type().NumIn() != len(args) {
			err = errors.New("incorrect number of parameters")
			return
		}
		g.Log().Debug(context.Background(), "执行的任务：", task.MethodName)
		for i := 0; i < method.Type().NumIn(); i++ {
			switch method.Type().In(i).Kind() {
			case reflect.Float32:
				args[i] = reflect.ValueOf(gconv.Float32(task.Params[i]))
			case reflect.Float64:
				args[i] = reflect.ValueOf(gconv.Float64(task.Params[i]))
			case reflect.Uint64:
				args[i] = reflect.ValueOf(gconv.Uint64(task.Params[i]))
			case reflect.Int64:
				args[i] = reflect.ValueOf(gconv.Int64(task.Params[i]))
			case reflect.Int:
				args[i] = reflect.ValueOf(gconv.Int(task.Params[i]))
			case reflect.Int32:
				args[i] = reflect.ValueOf(gconv.Int32(task.Params[i]))
			case reflect.Int16:
				args[i] = reflect.ValueOf(gconv.Int16(task.Params[i]))
			case reflect.Int8:
				args[i] = reflect.ValueOf(gconv.Int8(task.Params[i]))
			case reflect.Uint:
				args[i] = reflect.ValueOf(gconv.Uint(task.Params[i]))
			case reflect.Uint32:
				args[i] = reflect.ValueOf(gconv.Uint32(task.Params[i]))
			case reflect.Uint16:
				args[i] = reflect.ValueOf(gconv.Uint16(task.Params[i]))
			case reflect.Uint8:
				args[i] = reflect.ValueOf(gconv.Uint8(task.Params[i]))
			case reflect.String:
				args[i] = reflect.ValueOf(gconv.String(task.Params[i]))
			case reflect.Bool:
				args[i] = reflect.ValueOf(gconv.Bool(task.Params[i]))
			default:
				args[i] = reflect.ValueOf(task.Params[i])
			}
		}
		if len(task.Params) > 0 {
			method.Call(args)
		} else {
			method.Call(nil)
		}
	} else {
		errInfo := fmt.Sprintf("Method not found: %s", task.MethodName)
		err = errors.New(errInfo)
	}
	return
}

// UnmarshalTask 解析TaskJob，使用自定义JSON解析来处理类型问题
func UnmarshalTask(data []byte) (*Task, error) {
	var task Task
	dec := json.NewDecoder(bytes.NewReader(data))
	// 使用json.Decoder逐个解析Token，自定义解析逻辑
	for {
		t, err := dec.Token()
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, err
		}
		// 根据Token类型处理
		switch v := t.(type) {
		case float64:
			// 如果是数字 ，检查是否可以转换为整数
			if v == float64(int64(v)) {
				// 如果可以转换为整数，则转换为int类型
				task.Params = append(task.Params, int64(v))
			} else {
				// 如果不能转换为整数，则保留为float64类型
				task.Params = append(task.Params, v)
			}
		case string, bool, nil:
			// 对于字符串、布尔和空值，直接添加到Params中
			task.Params = append(task.Params, v)
			// 可以添加更多的类型处理
		}
	}
	return &task, nil
}

// CheckFuncName 检查方法名是否存在
func (tk *Tasks) CheckFuncName(funcName string) (actualfuncName string, exists bool) {
	exist := GetInnerTaskName(funcName)
	g.Log().Debug(context.Background(), "CheckFuncName", exist)
	if exist != "" {
		return exist, true
	}
	return
}

// ParseParameters 解析参数
func (tk *Tasks) ParseParameters(parseData string) (params []interface{}, err error) {
	parts := strings.Split(parseData, "|")
	params = make([]interface{}, len(parts))
	for i, part := range parts {
		params[i] = part
	}
	return
}