package jobs

import (
	"errors"
	"fmt"
	"go-admin/app/admin/models"
	"go-admin/app/admin/service"
	"go-admin/app/admin/service/dto"
	"go-admin/common/const/rediskey"
	"go-admin/common/helper"
	"time"

	"github.com/bytedance/sonic"
	"github.com/go-admin-team/go-admin-core/sdk"
	sysservice "github.com/go-admin-team/go-admin-core/sdk/service"
	"gorm.io/gorm"
)

// InitJob
// 需要将定义的struct 添加到字典中；
// 字典 key 可以配置到 自动任务 调用目标 中；
func InitJob() {
	jobList = map[string]JobExec{
		"ExamplesOne": ExamplesOne{},
		// ...
		"DeleteExpireOrder":              DeleteExpireOrder{},              //定时删除过期数据
		"UpRange":                        UpRange{},                        //更新涨跌幅
		"InitFuturesSymbol":              InitFuturesSymbol{},              //定时更新合约交易对
		"InitSpotSymbol":                 InitSpotSymbol{},                 //定时更新现货交易对
		"ClearLogJob":                    ClearLogJob{},                    //定时清理日志
		"AutoPlaceOrder":                 AutoPlaceOrder{},                 //定时下单
		"LimitOrderTimeoutDuration":      LimitOrderTimeoutDuration{},      //定时取消限价单改下市价单
		"ListenSymbol":                   ListenSymbol{},                   //交易对监听
		"MemberExpirationJob":            MemberExpirationJob{},            //会员到期处理
		"MemberRenwalOrderExpirationJob": MemberRenwalOrderExpirationJob{}, //会员续费订单过期处理
		"TrxQueryJobs":                   TrxQueryJobs{},                   //订单支付监听
	}
}

// ExamplesOne
// 新添加的job 必须按照以下格式定义，并实现Exec函数
type ExamplesOne struct {
}

func (t ExamplesOne) Exec(arg interface{}) error {
	str := time.Now().Format(timeFormat) + " [INFO] JobCore ExamplesOne exec success"
	// TODO: 这里需要注意 Examples 传入参数是 string 所以 arg.(string)；请根据对应的类型进行转化；
	switch arg.(type) {

	case string:
		if arg.(string) != "" {
			fmt.Println("string", arg.(string))
			fmt.Println(str, arg.(string))
		} else {
			fmt.Println("arg is nil")
			fmt.Println(str, "arg is nil")
		}
		break
	}

	return nil
}

// DeleteExpireOrder 清理过期订单
type DeleteExpireOrder struct {
}

func (receiver DeleteExpireOrder) Exec(arg interface{}) error {
	dbs := sdk.Runtime.GetDb()
	var db *gorm.DB

	for _, item := range dbs {
		db = item
		break
	}
	orders := make([]models.LinePreOrder, 0)
	err := db.Model(&models.LinePreOrder{}).Where("status = '0' AND expire_time <= ? AND order_type = 0 AND pid=0", time.Now()).Find(&orders).Error
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		return err
	}
	for _, order := range orders {
		//删除止盈止损数据
		db.Model(&models.LinePreOrder{}).Where("pid = ?", order.Id).Unscoped().Delete(&models.LinePreOrder{})
		//删除缓存
		list := dto.PreOrderRedisList{
			Id:          order.Id,
			Symbol:      order.Symbol,
			Price:       order.Price,
			Site:        order.Site,
			ApiId:       order.ApiId,
			OrderSn:     order.OrderSn,
			QuoteSymbol: order.QuoteSymbol,
		}
		marshal, _ := sonic.Marshal(&list)
		if order.SymbolType == 1 {
			helper.DefaultRedis.LRem(fmt.Sprintf(rediskey.PreSpotOrderList, order.ExchangeType), string(marshal))
		} else {
			helper.DefaultRedis.LRem(fmt.Sprintf(rediskey.PreFutOrderList, order.ExchangeType), string(marshal))
		}
		//删除主单
		db.Model(&models.LinePreOrder{}).Where("id = ?", order.Id).Unscoped().Delete(&models.LinePreOrder{})
	}
	return nil
}

// UpRange 更新涨跌幅
type UpRange struct {
}

func (receiver UpRange) Exec(arg interface{}) error {
	dbs := sdk.Runtime.GetDb()
	var db *gorm.DB

	for _, item := range dbs {
		db = item
		break
	}

	limit := service.LinePriceLimit{
		Service: sysservice.Service{Orm: db},
	}
	err := limit.UpRange()
	if err != nil {
		return err
	}
	return nil
}