package service

import (
	"dianshang/internal/model"
	"dianshang/internal/repository"
	"dianshang/pkg/jwt"
	"errors"
	"time"

	"golang.org/x/crypto/bcrypt"
	"gorm.io/gorm"
)

// AdminService 管理员服务
type AdminService struct {
	adminRepo *repository.AdminRepository
	db        *gorm.DB
}

// NewAdminService 创建管理员服务
func NewAdminService(db *gorm.DB) *AdminService {
	return &AdminService{
		adminRepo: repository.NewAdminRepository(db),
		db:        db,
	}
}

// LoginRequest 管理员登录请求
type LoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

// CreateAdminRequest 创建管理员请求
type CreateAdminRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required,min=6"`
	Nickname string `json:"nickname"`
	Email    string `json:"email"`
	Phone    string `json:"phone"`
	RoleID   uint   `json:"role_id" binding:"required"`
}

// UpdateAdminRequest 更新管理员请求
type UpdateAdminRequest struct {
	Nickname string `json:"nickname"`
	Email    string `json:"email"`
	Phone    string `json:"phone"`
	RoleID   uint   `json:"role_id"`
	Status   *uint8 `json:"status"`
}

// AdminLoginResponse 管理员登录响应
type AdminLoginResponse struct {
	Token     string           `json:"token"`
	AdminUser *model.AdminUser `json:"admin_user"`
}

// Login 管理员登录
func (s *AdminService) Login(req *LoginRequest) (*AdminLoginResponse, error) {
	// 查找管理员
	admin, err := s.adminRepo.GetByUsername(req.Username)
	if err != nil {
		if errors.Is(err, gorm.ErrRecordNotFound) {
			return nil, errors.New("用户名或密码错误")
		}
		return nil, err
	}

	// 检查管理员状态
	if admin.Status == 0 {
		return nil, errors.New("账户已被禁用")
	}

	// 验证密码
	if err := bcrypt.CompareHashAndPassword([]byte(admin.Password), []byte(req.Password)); err != nil {
		return nil, errors.New("用户名或密码错误")
	}

	// 生成JWT token
	tokenExpiry := 8 * 3600 // 8小时有效期
	token, err := jwt.GenerateToken(admin.ID, "admin", tokenExpiry)
	if err != nil {
		return nil, errors.New("生成token失败")
	}

	// 更新最后登录时间
	now := time.Now()
	admin.LastLogin = &now
	s.adminRepo.Update(admin.ID, map[string]interface{}{
		"last_login": now,
	})

	// 加载角色信息
	admin, _ = s.adminRepo.GetByIDWithRole(admin.ID)

	return &AdminLoginResponse{
		Token:     token,
		AdminUser: admin,
	}, nil
}

// CreateAdmin 创建管理员
func (s *AdminService) CreateAdmin(req *CreateAdminRequest) (*model.AdminUser, error) {
	// 检查用户名是否已存在
	if _, err := s.adminRepo.GetByUsername(req.Username); err == nil {
		return nil, errors.New("用户名已存在")
	}

	// 加密密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
	if err != nil {
		return nil, errors.New("密码加密失败")
	}

	// 创建管理员
	admin := &model.AdminUser{
		Username: req.Username,
		Password: string(hashedPassword),
		Nickname: req.Nickname,
		Email:    req.Email,
		Phone:    req.Phone,
		RoleID:   req.RoleID,
		Status:   1, // 默认启用
	}

	if err := s.adminRepo.Create(admin); err != nil {
		return nil, err
	}

	// 返回时不包含密码
	admin.Password = ""
	return admin, nil
}

// GetAdminList 获取管理员列表
func (s *AdminService) GetAdminList(page, pageSize int, keyword string) ([]model.AdminUser, int64, error) {
	return s.adminRepo.GetList(page, pageSize, keyword)
}

// GetAdminByID 根据ID获取管理员
func (s *AdminService) GetAdminByID(id uint) (*model.AdminUser, error) {
	return s.adminRepo.GetByIDWithRole(id)
}

// UpdateAdmin 更新管理员
func (s *AdminService) UpdateAdmin(id uint, req *UpdateAdminRequest) error {
	updates := make(map[string]interface{})
	
	if req.Nickname != "" {
		updates["nickname"] = req.Nickname
	}
	if req.Email != "" {
		updates["email"] = req.Email
	}
	if req.Phone != "" {
		updates["phone"] = req.Phone
	}
	if req.RoleID != 0 {
		updates["role_id"] = req.RoleID
	}
	if req.Status != nil {
		updates["status"] = *req.Status
	}

	return s.adminRepo.Update(id, updates)
}

// DeleteAdmin 删除管理员
func (s *AdminService) DeleteAdmin(id uint) error {
	return s.adminRepo.Delete(id)
}

// ChangePassword 修改密码
func (s *AdminService) ChangePassword(id uint, oldPassword, newPassword string) error {
	// 获取管理员信息
	admin, err := s.adminRepo.GetByID(id)
	if err != nil {
		return err
	}

	// 验证旧密码
	if err := bcrypt.CompareHashAndPassword([]byte(admin.Password), []byte(oldPassword)); err != nil {
		return errors.New("原密码错误")
	}

	// 加密新密码
	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
	if err != nil {
		return errors.New("密码加密失败")
	}

	// 更新密码
	return s.adminRepo.Update(id, map[string]interface{}{
		"password": string(hashedPassword),
	})
}

// GetProfile 获取管理员个人信息
func (s *AdminService) GetProfile(id uint) (*model.AdminUser, error) {
	admin, err := s.adminRepo.GetByIDWithRole(id)
	if err != nil {
		return nil, err
	}
	
	// 不返回密码
	admin.Password = ""
	return admin, nil
}

// UpdateProfile 更新管理员个人信息
func (s *AdminService) UpdateProfile(id uint, nickname, email, phone string) error {
	updates := make(map[string]interface{})
	
	if nickname != "" {
		updates["nickname"] = nickname
	}
	if email != "" {
		updates["email"] = email
	}
	if phone != "" {
		updates["phone"] = phone
	}

	return s.adminRepo.Update(id, updates)
}