package daytask

import (
	"app/commons/model/entity"
	"github.com/gin-gonic/gin"
	"golang.org/x/crypto/bcrypt"
)

// UserInfo 用户信息
func (s *Server) UserInfo(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	user := &entity.DtUser{}
	if err := db.Where("id = ?", userId).First(user).Error; err != nil {
		ctx.Fail("user_not_found")
		return
	}

	// 获取用户等级
	level := &entity.DtUserLevel{}
	db.Where("id = ?", user.LevelId).First(level)

	ctx.OK(gin.H{
		"user":  user,
		"level": level,
	})
}

// UserUpdate 更新用户信息
func (s *Server) UserUpdate(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	type UpdateRequest struct {
		Nickname string `json:"nickname"`
		Avatar   string `json:"avatar"`
		Gender   *int8  `json:"gender"`
		Age      *int   `json:"age"`
		Region   string `json:"region"`
		RealName string `json:"realName"`
		IdCard   string `json:"idCard"`
	}

	var req UpdateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ctx.Fail("invalid_params")
		return
	}

	updates := make(map[string]interface{})
	if req.Nickname != "" {
		updates["nickname"] = req.Nickname
	}
	if req.Avatar != "" {
		updates["avatar"] = req.Avatar
	}
	if req.Gender != nil {
		updates["gender"] = *req.Gender
	}
	if req.Age != nil {
		updates["age"] = *req.Age
	}
	if req.Region != "" {
		updates["region"] = req.Region
	}

	// 实名信息只能设置一次
	user := &entity.DtUser{}
	db.Where("id = ?", userId).First(user)

	if req.RealName != "" && user.RealName == "" {
		updates["real_name"] = req.RealName
	}
	if req.IdCard != "" && user.IdCard == "" {
		updates["id_card"] = req.IdCard
		updates["is_real_name"] = 1
	}

	if len(updates) > 0 {
		db.Model(&entity.DtUser{}).Where("id = ?", userId).Updates(updates)
	}

	ctx.OK(nil)
}

// UserPassword 修改密码
func (s *Server) UserPassword(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	type PasswordRequest struct {
		OldPassword string `json:"oldPassword" binding:"required"`
		NewPassword string `json:"newPassword" binding:"required,min=6"`
	}

	var req PasswordRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ctx.Fail("invalid_params")
		return
	}

	user := &entity.DtUser{}
	if err := db.Where("id = ?", userId).First(user).Error; err != nil {
		ctx.Fail("user_not_found")
		return
	}

	// 验证旧密码
	if err := bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(req.OldPassword)); err != nil {
		ctx.Fail("old_password_error")
		return
	}

	// 加密新密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.NewPassword), bcrypt.DefaultCost)
	if err != nil {
		ctx.Fail("system_error")
		return
	}
	db.Model(&entity.DtUser{}).Where("id = ?", userId).Update("password", string(hashedPassword))

	ctx.OK(nil)
}

// UserAvatar 修改头像
func (s *Server) UserAvatar(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	type AvatarRequest struct {
		Avatar string `json:"avatar" binding:"required"`
	}

	var req AvatarRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ctx.Fail("invalid_params")
		return
	}

	db.Model(&entity.DtUser{}).Where("id = ?", userId).Update("avatar", req.Avatar)

	ctx.OK(nil)
}

// PaymentList 收款账户列表
func (s *Server) PaymentList(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	payments := make([]*entity.DtUserPayment, 0)
	db.Model(&entity.DtUserPayment{}).
		Where("user_id = ? AND status = ?", userId, 1).
		Order("is_default DESC, id DESC").
		Find(&payments)

	ctx.OK(payments)
}

// PaymentAdd 添加收款账户
func (s *Server) PaymentAdd(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	type PaymentRequest struct {
		Type       string `json:"type" binding:"required"`
		Name       string `json:"name"`
		Account    string `json:"account" binding:"required"`
		BankName   string `json:"bankName"`
		BankBranch string `json:"bankBranch"`
		Qrcode     string `json:"qrcode"`
	}

	var req PaymentRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ctx.Fail("invalid_params")
		return
	}

	// 检查是否已存在相同类型的账户
	var count int64
	db.Model(&entity.DtUserPayment{}).
		Where("user_id = ? AND type = ? AND account = ?", userId, req.Type, req.Account).
		Count(&count)
	if count > 0 {
		ctx.Fail("payment_exists")
		return
	}

	// 检查是否有默认账户
	var defaultCount int64
	db.Model(&entity.DtUserPayment{}).
		Where("user_id = ? AND is_default = ?", userId, 1).
		Count(&defaultCount)

	payment := &entity.DtUserPayment{
		UserId:     userId,
		Type:       req.Type,
		Name:       req.Name,
		Account:    req.Account,
		BankName:   req.BankName,
		BankBranch: req.BankBranch,
		Qrcode:     req.Qrcode,
		IsDefault:  0,
		Status:     1,
	}

	// 如果没有默认账户，设为默认
	if defaultCount == 0 {
		payment.IsDefault = 1
	}

	db.Create(payment)

	ctx.OK(payment)
}

// PaymentDelete 删除收款账户
func (s *Server) PaymentDelete(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	type DeleteRequest struct {
		Id int64 `json:"id" binding:"required"`
	}

	var req DeleteRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ctx.Fail("invalid_params")
		return
	}

	db.Where("id = ? AND user_id = ?", req.Id, userId).Delete(&entity.DtUserPayment{})

	ctx.OK(nil)
}

// PaymentDefault 设置默认账户
func (s *Server) PaymentDefault(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	type DefaultRequest struct {
		Id int64 `json:"id" binding:"required"`
	}

	var req DefaultRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ctx.Fail("invalid_params")
		return
	}

	// 取消其他默认
	db.Model(&entity.DtUserPayment{}).
		Where("user_id = ?", userId).
		Update("is_default", 0)

	// 设置新默认
	db.Model(&entity.DtUserPayment{}).
		Where("id = ? AND user_id = ?", req.Id, userId).
		Update("is_default", 1)

	ctx.OK(nil)
}

// SocialList 社交账号列表
func (s *Server) SocialList(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	socials := make([]*entity.DtUserSocial, 0)
	db.Model(&entity.DtUserSocial{}).
		Where("user_id = ?", userId).
		Find(&socials)

	ctx.OK(socials)
}

// SocialBind 绑定社交账号
func (s *Server) SocialBind(c *gin.Context) {
	ctx := s.FromContext(c)
	db := s.DB()
	userId := ctx.UserId()

	type BindRequest struct {
		Platform string `json:"platform" binding:"required"`
		Account  string `json:"account" binding:"required"`
		Nickname string `json:"nickname"`
	}

	var req BindRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		ctx.Fail("invalid_params")
		return
	}

	// 检查是否已绑定
	var existing entity.DtUserSocial
	err := db.Where("user_id = ? AND platform = ?", userId, req.Platform).First(&existing).Error

	if err == nil {
		// 更新
		db.Model(&entity.DtUserSocial{}).
			Where("id = ?", existing.Id).
			Updates(map[string]interface{}{
				"account":  req.Account,
				"nickname": req.Nickname,
			})
	} else {
		// 新增
		social := &entity.DtUserSocial{
			UserId:   userId,
			Platform: req.Platform,
			Account:  req.Account,
			Nickname: req.Nickname,
			Extra:    "{}",
			Status:   1,
		}
		db.Create(social)
	}

	ctx.OK(nil)
}