package dao

import (
	"database/sql"
	"fmt"

	"dd_fiber_api/internal/admin_auth"
	"dd_fiber_api/pkg/database"
	"dd_fiber_api/pkg/snowflake"

	"github.com/didi/gendry/builder"
)

// RoleDAO 角色数据访问对象
type RoleDAO struct {
	client *database.MySQLClient
}

// NewRoleDAO 创建角色DAO
func NewRoleDAO(client *database.MySQLClient) *RoleDAO {
	return &RoleDAO{
		client: client,
	}
}

// List 列出角色（支持分页和搜索）
func (d *RoleDAO) List(keyword string, page, pageSize int) ([]*admin_auth.AdminRole, int, error) {
	table := "admin_roles"

	// 构建查询条件
	where := map[string]any{}
	if keyword != "" {
		where["_or"] = []map[string]any{
			{"name like": "%" + keyword + "%"},
			{"code like": "%" + keyword + "%"},
			{"description like": "%" + keyword + "%"},
		}
	}

	// 查询总数
	countFields := []string{"COUNT(*) as total"}
	countCond, countVals, err := builder.BuildSelect(table, where, countFields)
	if err != nil {
		return nil, 0, fmt.Errorf("构建统计查询失败: %v", err)
	}

	var total int
	err = d.client.DB.QueryRow(countCond, countVals...).Scan(&total)
	if err != nil {
		return nil, 0, fmt.Errorf("查询角色总数失败: %v", err)
	}

	// 查询数据
	selectFields := []string{"id", "name", "code", "description", "status", "created_at", "updated_at"}
	cond, vals, err := builder.BuildSelect(table, where, selectFields)
	if err != nil {
		return nil, 0, fmt.Errorf("构建查询失败: %v", err)
	}

	// 添加排序和分页
	offset := (page - 1) * pageSize
	cond += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
	vals = append(vals, pageSize, offset)

	rows, err := d.client.DB.Query(cond, vals...)
	if err != nil {
		return nil, 0, fmt.Errorf("查询角色列表失败: %v", err)
	}
	defer rows.Close()

	var roles []*admin_auth.AdminRole
	for rows.Next() {
		var role admin_auth.AdminRole
		var description sql.NullString

		err := rows.Scan(
			&role.ID,
			&role.Name,
			&role.Code,
			&description,
			&role.Status,
			&role.CreatedAt,
			&role.UpdatedAt,
		)
		if err != nil {
			continue
		}

		if description.Valid {
			role.Description = description.String
		}

		roles = append(roles, &role)
	}

	return roles, total, nil
}

// GetByID 根据ID获取角色
func (d *RoleDAO) GetByID(id string) (*admin_auth.AdminRole, error) {
	query := `SELECT id, name, code, description, status, created_at, updated_at 
	          FROM admin_roles WHERE id = ?`

	var role admin_auth.AdminRole
	var description sql.NullString

	err := d.client.DB.QueryRow(query, id).Scan(
		&role.ID,
		&role.Name,
		&role.Code,
		&description,
		&role.Status,
		&role.CreatedAt,
		&role.UpdatedAt,
	)

	if err == sql.ErrNoRows {
		return nil, nil
	}
	if err != nil {
		return nil, fmt.Errorf("查询角色失败: %v", err)
	}

	if description.Valid {
		role.Description = description.String
	}

	return &role, nil
}

// GetByCode 根据代码获取角色
func (d *RoleDAO) GetByCode(code string) (*admin_auth.AdminRole, error) {
	query := `SELECT id, name, code, description, status, created_at, updated_at 
	          FROM admin_roles WHERE code = ?`

	var role admin_auth.AdminRole
	var description sql.NullString

	err := d.client.DB.QueryRow(query, code).Scan(
		&role.ID,
		&role.Name,
		&role.Code,
		&description,
		&role.Status,
		&role.CreatedAt,
		&role.UpdatedAt,
	)

	if err == sql.ErrNoRows {
		return nil, nil
	}
	if err != nil {
		return nil, fmt.Errorf("查询角色失败: %v", err)
	}

	if description.Valid {
		role.Description = description.String
	}

	return &role, nil
}

// Create 创建角色
func (d *RoleDAO) Create(role *admin_auth.AdminRole) error {
	table := "admin_roles"
	data := []map[string]any{
		{
			"id":          role.ID,
			"name":        role.Name,
			"code":        role.Code,
			"description": role.Description,
			"status":      role.Status,
		},
	}

	cond, vals, err := builder.BuildInsert(table, data)
	if err != nil {
		return fmt.Errorf("构建插入语句失败: %v", err)
	}

	_, err = d.client.DB.Exec(cond, vals...)
	if err != nil {
		return fmt.Errorf("创建角色失败: %v", err)
	}

	return nil
}

// Update 更新角色
func (d *RoleDAO) Update(role *admin_auth.AdminRole) error {
	table := "admin_roles"
	where := map[string]any{
		"id": role.ID,
	}

	data := map[string]any{
		"name":        role.Name,
		"code":        role.Code,
		"description": role.Description,
		"status":      role.Status,
	}

	cond, vals, err := builder.BuildUpdate(table, where, data)
	if err != nil {
		return fmt.Errorf("构建更新语句失败: %v", err)
	}

	_, err = d.client.DB.Exec(cond, vals...)
	if err != nil {
		return fmt.Errorf("更新角色失败: %v", err)
	}

	return nil
}

// Delete 删除角色（软删除，更新状态为禁用）
func (d *RoleDAO) Delete(id string) error {
	where := map[string]any{
		"id": id,
	}
	data := map[string]any{
		"status": 0, // 禁用状态
	}

	cond, vals, err := builder.BuildUpdate("admin_roles", where, data)
	if err != nil {
		return fmt.Errorf("构建更新语句失败: %v", err)
	}

	_, err = d.client.DB.Exec(cond, vals...)
	if err != nil {
		return fmt.Errorf("删除角色失败: %v", err)
	}

	return nil
}

// GetRolePermissions 获取角色的权限列表
func (d *RoleDAO) GetRolePermissions(roleID string) ([]string, error) {
	query := `SELECT permission_id FROM admin_role_permissions WHERE role_id = ?`

	rows, err := d.client.DB.Query(query, roleID)
	if err != nil {
		return nil, fmt.Errorf("查询角色权限失败: %v", err)
	}
	defer rows.Close()

	var permissionIDs []string
	for rows.Next() {
		var permissionID string
		if err := rows.Scan(&permissionID); err != nil {
			continue
		}
		permissionIDs = append(permissionIDs, permissionID)
	}

	return permissionIDs, nil
}

// SetRolePermissions 设置角色的权限
func (d *RoleDAO) SetRolePermissions(roleID string, permissionIDs []string) error {
	// 先删除原有权限
	deleteQuery := `DELETE FROM admin_role_permissions WHERE role_id = ?`
	_, err := d.client.DB.Exec(deleteQuery, roleID)
	if err != nil {
		return fmt.Errorf("删除角色权限失败: %v", err)
	}

	// 插入新权限
	if len(permissionIDs) > 0 {
		table := "admin_role_permissions"
		data := make([]map[string]any, 0, len(permissionIDs))
		for _, permissionID := range permissionIDs {
			// 生成关联ID
			id, err := d.generateID()
			if err != nil {
				return fmt.Errorf("生成ID失败: %v", err)
			}
			data = append(data, map[string]any{
				"id":            id,
				"role_id":       roleID,
				"permission_id": permissionID,
			})
		}

		cond, vals, err := builder.BuildInsert(table, data)
		if err != nil {
			return fmt.Errorf("构建插入语句失败: %v", err)
		}

		_, err = d.client.DB.Exec(cond, vals...)
		if err != nil {
			return fmt.Errorf("设置角色权限失败: %v", err)
		}
	}

	return nil
}

// generateID 生成ID（使用雪花算法）
func (d *RoleDAO) generateID() (string, error) {
	return snowflake.GenerateID(), nil
}