package daytask

import (
	"encoding/json"

	model "go_server/model/biz_modules/daytask"
	"go_server/model/common/response"
	"go_server/service/base"

	"github.com/gin-gonic/gin"
)

// DtWithdrawOrderService 提现订单服务
type DtWithdrawOrderService struct {
	base.BizCommonService
}

func (s *DtWithdrawOrderService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtWithdrawOrder()).Get(c, s.DB())
}

func (s *DtWithdrawOrderService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id        *int64  `form:"id"`
		OrderNo   *string `form:"orderNo"`
		UserId    *int64  `form:"userId"`
		UserUid   *string `form:"userUid"`
		Channel   *string `form:"channel"`
		Status    *int8   `form:"status"`
		BeginTime *int64  `form:"beginTime"`
		EndTime   *int64  `form:"endTime"`
	}
	req := new(request[model.DtWithdrawOrder])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.Id != nil && *req.Id != 0 {
		db = db.Where("id", req.Id)
	}
	if req.OrderNo != nil && *req.OrderNo != "" {
		db = db.Where("order_no", req.OrderNo)
	}
	if req.UserId != nil && *req.UserId != 0 {
		db = db.Where("user_id", req.UserId)
	}
	if req.UserUid != nil && *req.UserUid != "" {
		db = db.Where("user_uid", req.UserUid)
	}
	if req.Channel != nil && *req.Channel != "" {
		db = db.Where("channel", req.Channel)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	if req.BeginTime != nil && *req.BeginTime > 0 && req.EndTime != nil && *req.EndTime > 0 {
		db = db.Where("created_at BETWEEN ? AND ?", *req.BeginTime, *req.EndTime)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtWithdrawOrder{})
	resp, err := base.NewQueryBaseHandler(model.NewDtWithdrawOrder()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}

	// 兼容旧数据：从 paymentInfo 中解析收款信息，补充到新字段
	type paymentInfo struct {
		Type     string `json:"type"`
		Name     string `json:"name"`
		Account  string `json:"account"`
		BankName string `json:"bankName"`
	}
	for i := range resp.List {
		info := resp.List[i].PaymentInfo
		if info == "" {
			continue
		}
		var p paymentInfo
		if err := json.Unmarshal([]byte(info), &p); err != nil {
			continue
		}
		if resp.List[i].Channel == "" {
			resp.List[i].Channel = p.Type
		}
		if resp.List[i].ReceiveAccount == "" {
			resp.List[i].ReceiveAccount = p.Account
		}
		if resp.List[i].ReceiveName == "" {
			resp.List[i].ReceiveName = p.Name
		}
		if resp.List[i].BankName == "" {
			resp.List[i].BankName = p.BankName
		}
	}

	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}

func (s *DtWithdrawOrderService) Create(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtWithdrawOrder()).Create(c, s.DB())
}

func (s *DtWithdrawOrderService) Update(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtWithdrawOrder()).UpdateOne(c, s.DB())
}

// Audit 审核提现
func (s *DtWithdrawOrderService) Audit(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request struct {
		Id           int64  `json:"id" binding:"required"`
		Status       int8   `json:"status" binding:"required"` // 1=审核通过 4=已拒绝
		RejectReason string `json:"rejectReason"`
		Remark       string `json:"remark"`
	}
	var req request
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Resp(c, err.Error())
		return
	}

	// 只允许审核通过(1)或拒绝(4)，其他状态视为参数错误
	if req.Status != 1 && req.Status != 4 {
		response.Resp(c, response.ResponseCodeParamError)
		return
	}

	updates := map[string]interface{}{
		"status":     req.Status,
		"remark":     req.Remark,
		"audit_time": c.GetInt64("now"),
	}
	if req.Status == 4 {
		updates["reject_reason"] = req.RejectReason
	}

	err := s.DB().Model(&model.DtWithdrawOrder{}).Where("id = ? AND status = 0", req.Id).Updates(updates).Error
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	// 使用默认成功响应（code=200,msg=操作成功）
	response.Resp(c)
}

// Pay 打款
func (s *DtWithdrawOrderService) Pay(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request struct {
		Id            int64  `json:"id" binding:"required"`
		Txid          string `json:"txid"`
		PayScreenshot string `json:"payScreenshot"`
		Remark        string `json:"remark"`
	}
	var req request
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Resp(c, err.Error())
		return
	}

	updates := map[string]interface{}{
		"status":         2,
		"txid":           req.Txid,
		"pay_screenshot": req.PayScreenshot,
		"remark":         req.Remark,
		"pay_time":       c.GetInt64("now"),
	}

	db := s.DB().Model(&model.DtWithdrawOrder{}).Where("id = ? AND status = 1", req.Id).Updates(updates)
	if db.Error != nil {
		response.Resp(c, db.Error.Error())
		return
	}
	// 如果没有行受影响，说明当前订单不在「审核通过」状态
	if db.RowsAffected == 0 {
		response.Resp(c, response.ResponseCodeParamError)
		return
	}
	// 使用默认成功响应（code=200,msg=操作成功）
	response.Resp(c)
}

// DtBalanceLogService 资金流水服务
type DtBalanceLogService struct {
	base.BizCommonService
}

func (s *DtBalanceLogService) Get(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtBalanceLog()).Get(c, s.DB())
}

func (s *DtBalanceLogService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		UserId    *int64  `form:"userId"`
		UserUid   *string `form:"userUid"`
		Type      *string `form:"type"`
		BeginTime *int64  `form:"beginTime"`
		EndTime   *int64  `form:"endTime"`
	}
	req := new(request[model.DtBalanceLog])
	if err := c.BindQuery(req); err != nil {
		response.Resp(c, err.Error())
		return
	}
	db := s.DB()
	if req.UserId != nil && *req.UserId != 0 {
		db = db.Where("user_id", req.UserId)
	}
	if req.UserUid != nil && *req.UserUid != "" {
		db = db.Where("user_uid", req.UserUid)
	}
	if req.Type != nil && *req.Type != "" {
		db = db.Where("type", req.Type)
	}
	if req.BeginTime != nil && *req.BeginTime > 0 && req.EndTime != nil && *req.EndTime > 0 {
		db = db.Where("created_at BETWEEN ? AND ?", *req.BeginTime, *req.EndTime)
	}

	colInfo := s.GetColumnCommentFromStruct(model.DtBalanceLog{})
	resp, err := base.NewQueryBaseHandler(model.NewDtBalanceLog()).List(db, req)
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, map[string]interface{}{
		"cols":   colInfo,
		"list":   resp.List,
		"paging": resp.Paging,
	})
}