package tools

import (
	"ai_scheduler/internal/config"
	"ai_scheduler/internal/entitys"
	"context"
	"encoding/json"
	"fmt"
)

type ZltxOrderAfterSaleResellerBatchTool struct {
	config config.ToolConfig
}

// NewZltxOrderAfterSaleResellerBatchTool 创建售后订单预检工具
func NewZltxOrderAfterSaleResellerBatchTool(config config.ToolConfig) *ZltxOrderAfterSaleResellerBatchTool {
	return &ZltxOrderAfterSaleResellerBatchTool{config: config}
}

// Name 返回工具名称
func (t *ZltxOrderAfterSaleResellerBatchTool) Name() string {
	return "zltxOrderAfterSaleResellerBatch"
}

func (t *ZltxOrderAfterSaleResellerBatchTool) Description() string {
	return "直连天下下游分销商批充订单售后工具"
}

func (t *ZltxOrderAfterSaleResellerBatchTool) Definition() entitys.ToolDefinition {
	return entitys.ToolDefinition{
		Type: "function",
		Function: entitys.FunctionDef{
			Name:        t.Name(),
			Description: t.Description(),
			Parameters:  map[string]interface{}{
				// "type": "object",
				// "properties": map[string]interface{}{
				// 	"orderType": map[string]interface{}{
				// 		"type":        "integer",
				// 		"description": "售后订单类型",
				// 	},
				// 	"orderNumber": map[string]interface{}{
				// 		"type":        "string",
				// 		"description": "售后订单号",
				// 	},
				// },
				// "required": []string{"orderType", "orderNumber"},
			},
		},
	}
}

type ZltxOrderAfterSaleResellerBatchRequest struct {
	OrderNumber       []string `json:"orderNumber"`       // 订单号
	AfterType         int      `json:"afterType"`         // 处理方式 1.退款 2.扣款
	AfterSalesPrice   string   `json:"afterSalesPrice"`   // 售后金额
	AfterSalesReason  string   `json:"afterSalesReason"`  // 售后原因
	ResponsibleType   int      `json:"responsibleType"`   // 费用承担者 1.供应商 2.商务 3.公司 4.无
	ResponsiblePerson string   `json:"responsiblePerson"` // 费用承担供应商
}

type ZltxOrderAfterSaleResellerBatchResponse struct {
	Code int                                   `json:"code"`
	Msg  string                                `json:"msg"`
	Data []ZltxOrderAfterSaleResellerBatchData `json:"data"`
}

type ZltxOrderAfterSaleResellerBatchData struct {
	OrderType         int            `json:"orderType"`
	OrderNumber       string         `json:"orderNumber"`
	OrderAmount       float64        `json:"orderAmount"`
	OrderPrice        float64        `json:"orderPrice"`
	SignCompany       int            `json:"signCompany"`
	OrderQuantity     int            `json:"orderQuantity"`
	ResellerID        int            `json:"resellerId"`
	ResellerName      string         `json:"resellerName"`
	OurProductID      int            `json:"ourProductId"`
	OurProductTitle   string         `json:"ourProductTitle"`
	Account           []string       `json:"account"`
	Platforms         map[int]string `json:"platforms"`
	CreateTime        string         `json:"createTime"`        // 创建时间
	AfterType         int            `json:"afterType"`         // 处理方式 1.退款 2.扣款
	Remark            string         `json:"remark"`            // 售后原因
	AfterAmount       float64        `json:"afterAmount"`       // 售后金额
	ResponsibleType   int            `json:"responsibleType"`   // 费用承担者 1.供应商 2.商务 3.公司 4.无
	ResponsiblePerson string         `json:"responsiblePerson"` // 费用承担供应商
	IsExistsAfterSale bool           `json:"isExistsAfterSale"` // 是否已存在售后
}

func (t *ZltxOrderAfterSaleResellerBatchTool) Execute(ctx context.Context, requireData *entitys.RequireData) error {
	var req ZltxOrderAfterSaleResellerBatchRequest
	if err := json.Unmarshal([]byte(requireData.Match.Parameters), &req); err != nil {
		return err
	}
	if len(req.OrderNumber) == 0 {
		return fmt.Errorf("批充订单号不能为空")
	}

	entitys.ResLog(requireData.Ch, t.Name(), "正在拉取售后订单信息")

	return t.checkZltxOrderAfterSaleResellerBatch(req, requireData)
}

func (t *ZltxOrderAfterSaleResellerBatchTool) checkZltxOrderAfterSaleResellerBatch(req ZltxOrderAfterSaleResellerBatchRequest, requireData *entitys.RequireData) error {
	// req := l_request.Request{
	// 	Url: t.config.BaseURL,
	// 	Headers: map[string]string{
	// 		"Authorization": fmt.Sprintf("Bearer %s", requireData.Auth),
	// 	},
	// 	Method: "POST",
	// 	Data: map[string]string{
	// 		// "orderType":   fmt.Sprintf("%d", orderType),
	// 		"orderNumber": orderNumber,
	// 	},
	// }
	// res, err := req.Send()
	// if err != nil {
	// 	return err
	// }
	// // 解析响应
	// var resp ZltxOrderAfterSaleResellerBatchResponse
	// if err := json.Unmarshal(res.Content, &resp); err != nil {
	// 	return err
	// }
	// if resp.Code != 0 {
	// 	return fmt.Errorf("check failed: %s", resp.Msg)
	// }

	// === mock start ===
	resp := ZltxOrderAfterSaleResellerBatchResponse{
		Code: 0,
		Msg:  "success",
		Data: []ZltxOrderAfterSaleResellerBatchData{
			{
				OrderType:         1,
				OrderNumber:       "846784115378364417",
				OrderAmount:       0.1,
				OrderPrice:        0.1,
				SignCompany:       1,
				OrderQuantity:     1,
				ResellerID:        23329,
				ResellerName:      "分销商23329",
				OurProductID:      106,
				OurProductTitle:   "爱奇艺黄金会员周卡",
				Account:           []string{"15516353308"},
				Platforms:         map[int]string{4: "爱奇艺"},
				CreateTime:        "2025-08-10 10:00:00",
				AfterType:         1,
				Remark:            "测试售后",
				AfterAmount:       50,
				ResponsibleType:   1,
				IsExistsAfterSale: false,
			},
			{
				OrderType:         101,
				OrderNumber:       "846052057729867777",
				OrderAmount:       23,
				OrderPrice:        23,
				SignCompany:       1,
				OrderQuantity:     1,
				ResellerID:        25629,
				ResellerName:      "二期财务分销商简称",
				OurProductID:      104,
				OurProductTitle:   "优酷年卡",
				Account:           []string{"18380416326"},
				Platforms:         map[int]string{1: "爱瓦力"},
				CreateTime:        "2025-08-11 10:00:00",
				AfterType:         2,
				Remark:            "测试售后2",
				AfterAmount:       30,
				ResponsibleType:   2,
				IsExistsAfterSale: false,
			},
		},
	}

	if len(req.OrderNumber) == 1 {
		resp.Data = resp.Data[:1]
	}
	// === mock end ===

	jsonByte, err := json.Marshal(resp)
	if err != nil {
		return err
	}

	entitys.ResLog(requireData.Ch, t.Name(), "售后订单信息拉取完成")
	entitys.ResJson(requireData.Ch, t.Name(), string(jsonByte))
	return nil
}