package daytask

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

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

// DtRechargeOrderService 充值订单服务
type DtRechargeOrderService struct {
	base.BizCommonService
}

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

func (s *DtRechargeOrderService) 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.DtRechargeOrder])
	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.DtRechargeOrder{})
	resp, err := base.NewQueryBaseHandler(model.NewDtRechargeOrder()).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,
	})
}

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

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

// Confirm 确认充值
func (s *DtRechargeOrderService) Confirm(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request struct {
		Id           int64   `json:"id" binding:"required"`
		Status       int8    `json:"status" binding:"required"` // 2=完成 3=取消
		ActualAmount float64 `json:"actualAmount"`
		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":       req.Status,
		"remark":       req.Remark,
		"confirm_time": c.GetInt64("now"),
	}
	if req.ActualAmount > 0 {
		updates["actual_amount"] = req.ActualAmount
	}

	err := s.DB().Model(&model.DtRechargeOrder{}).Where("id = ? AND status = 1", req.Id).Updates(updates).Error
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	response.Resp(c, "操作成功")
}

// 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
	}
	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
	}

	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
	}
	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"),
	}

	err := s.DB().Model(&model.DtWithdrawOrder{}).Where("id = ? AND status = 1", req.Id).Updates(updates).Error
	if err != nil {
		response.Resp(c, err.Error())
		return
	}
	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,
	})
}

// DtPaymentChannelService 支付渠道服务
type DtPaymentChannelService struct {
	base.BizCommonService
}

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

func (s *DtPaymentChannelService) Find(c *gin.Context) {
	s.SetDbAlias("daytask")
	type request[T any] struct {
		base.ListRequest[T]
		Id     *int64  `form:"id"`
		Code   *string `form:"code"`
		Type   *int8   `form:"type"`
		Status *int8   `form:"status"`
	}
	req := new(request[model.DtPaymentChannel])
	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.Code != nil && *req.Code != "" {
		db = db.Where("code", req.Code)
	}
	if req.Type != nil {
		db = db.Where("type", req.Type)
	}
	if req.Status != nil {
		db = db.Where("status", req.Status)
	}
	db = db.Order("sort ASC")

	colInfo := s.GetColumnCommentFromStruct(model.DtPaymentChannel{})
	resp, err := base.NewQueryBaseHandler(model.NewDtPaymentChannel()).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,
	})
}

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

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

func (s *DtPaymentChannelService) Delete(c *gin.Context) {
	s.SetDbAlias("daytask")
	base.NewBaseHandler(model.NewDtPaymentChannel()).DeleteOne(c, s.DB())
}