package services
 
 import (
 	"errors"
 	"time"
 
 	"github.com/inchstep/server/internal/models"
 	"golang.org/x/crypto/bcrypt"
 	"gorm.io/gorm"
 )
 
 type AdminService struct {
 	db      *gorm.DB
 	userSvc *UserService
 }
 
 func NewAdminService(db *gorm.DB, userSvc *UserService) *AdminService {
 	return &AdminService{db: db, userSvc: userSvc}
 }
 
 // SeedAdmin 初始化超级管理员账号
 func (s *AdminService) SeedAdmin() error {
 	var count int64
 	s.db.Model(&models.Admin{}).Count(&count)
 	if count > 0 {
 		return nil // 已有管理员，跳过
 	}
 	hash, err := bcrypt.GenerateFromPassword([]byte("admin123456"), 12)
 	if err != nil {
 		return err
 	}
 	nick := "超级管理员"
 	admin := &models.Admin{
 		ID:           generateID(),
 		Username:     "admin",
 		PasswordHash: string(hash),
 		Nickname:     &nick,
 		Role:         models.RoleSuperAdmin,
 		Status:       models.AdminStatusActive,
 		CreatedAt:    time.Now(),
 		UpdatedAt:    time.Now(),
 	}
 	return s.db.Create(admin).Error
 }
 
 // Login 管理员登录
 func (s *AdminService) Login(username, password string) (*models.Admin, error) {
 	var admin models.Admin
 	if err := s.db.Where("username = ?", username).First(&admin).Error; err != nil {
 		return nil, errors.New("用户名或密码错误")
 	}
 	if admin.Status != models.AdminStatusActive {
 		return nil, errors.New("账号已被禁用")
 	}
 	if err := bcrypt.CompareHashAndPassword([]byte(admin.PasswordHash), []byte(password)); err != nil {
 		return nil, errors.New("用户名或密码错误")
 	}
 	return &admin, nil
 }
 
 // GetDashboardStats 获取管理后台统计数据
 func (s *AdminService) GetDashboardStats() (map[string]interface{}, error) {
 	var totalUsers, todayUsers int64
 	s.db.Model(&models.User{}).Count(&totalUsers)
 	todayStart := time.Now().Truncate(24 * time.Hour)
 	s.db.Model(&models.User{}).Where("created_at >= ?", todayStart).Count(&todayUsers)
 
 	var totalPosts, totalItems, totalRecords int64
 	s.db.Model(&models.Post{}).Where("privacy = ?", 1).Count(&totalPosts)
 	s.db.Model(&models.CheckInItem{}).Count(&totalItems)
 	s.db.Model(&models.CheckInRecord{}).Count(&totalRecords)
 
 	return map[string]interface{}{
 		"totalUsers":    totalUsers,
 		"totalPosts":    totalPosts,
 		"totalItems":    totalItems,
 		"totalRecords":  totalRecords,
 		"newUsersToday": todayUsers,
 	}, nil
 }
 
 // ListUsers 获取用户列表（分页）
 func (s *AdminService) ListUsers(page, pageSize int) ([]models.User, int64, error) {
 	var total int64
 	s.db.Model(&models.User{}).Count(&total)
 	var users []models.User
 	err := s.db.Order("created_at desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&users).Error
 	return users, total, err
 }
 
 // ListPosts 获取动态列表
 func (s *AdminService) ListPosts(page, pageSize int) ([]models.Post, int64, error) {
 	var total int64
 	s.db.Model(&models.Post{}).Count(&total)
 	var posts []models.Post
 	err := s.db.Preload("User").Order("created_at desc").Offset((page - 1) * pageSize).Limit(pageSize).Find(&posts).Error
 	return posts, total, err
 }
 
 // ListAdmins 获取管理员列表
 func (s *AdminService) ListAdmins() ([]models.Admin, error) {
 	var admins []models.Admin
 	err := s.db.Find(&admins).Error
 	return admins, err
 }
 
 // CreateAdmin 创建管理员
 func (s *AdminService) CreateAdmin(username, password, role string, nickname *string) (*models.Admin, error) {
 	var existing models.Admin
 	if err := s.db.Where("username = ?", username).First(&existing).Error; err == nil {
 		return nil, errors.New("用户名已存在")
 	}
 	hash, err := bcrypt.GenerateFromPassword([]byte(password), 12)
 	if err != nil {
 		return nil, err
 	}
 	admin := &models.Admin{
 		ID:           generateID(),
 		Username:     username,
 		PasswordHash: string(hash),
 		Nickname:     nickname,
 		Role:         models.AdminRole(role),
 		Status:       models.AdminStatusActive,
 		CreatedAt:    time.Now(),
 		UpdatedAt:    time.Now(),
 	}
 	return admin, s.db.Create(admin).Error
 }
 
 // DisableAdmin 禁用管理员
 func (s *AdminService) DisableAdmin(id string) error {
 	return s.db.Model(&models.Admin{}).Where("id = ?", id).Update("status", models.AdminStatusDisabled).Error
 }