package postgres

import (
	"context"
	"time"

	"github.com/break/junhong_cmp_fiber/internal/store"

	"github.com/break/junhong_cmp_fiber/internal/model"
	"github.com/break/junhong_cmp_fiber/pkg/constants"
	"github.com/bytedance/sonic"
	"github.com/redis/go-redis/v9"
	"gorm.io/gorm"
)

// AccountStore 账号数据访问层
type AccountStore struct {
	db    *gorm.DB
	redis *redis.Client
}

// NewAccountStore 创建账号 Store
func NewAccountStore(db *gorm.DB, redis *redis.Client) *AccountStore {
	return &AccountStore{
		db:    db,
		redis: redis,
	}
}

// Create 创建账号
func (s *AccountStore) Create(ctx context.Context, account *model.Account) error {
	return s.db.WithContext(ctx).Create(account).Error
}

// GetByID 根据 ID 获取账号
func (s *AccountStore) GetByID(ctx context.Context, id uint) (*model.Account, error) {
	var account model.Account
	if err := s.db.WithContext(ctx).First(&account, id).Error; err != nil {
		return nil, err
	}
	return &account, nil
}

// GetByUsername 根据用户名获取账号
func (s *AccountStore) GetByUsername(ctx context.Context, username string) (*model.Account, error) {
	var account model.Account
	if err := s.db.WithContext(ctx).Where("username = ?", username).First(&account).Error; err != nil {
		return nil, err
	}
	return &account, nil
}

// GetByPhone 根据手机号获取账号
func (s *AccountStore) GetByPhone(ctx context.Context, phone string) (*model.Account, error) {
	var account model.Account
	if err := s.db.WithContext(ctx).Where("phone = ?", phone).First(&account).Error; err != nil {
		return nil, err
	}
	return &account, nil
}

// GetByShopID 根据店铺 ID 查询账号列表
func (s *AccountStore) GetByShopID(ctx context.Context, shopID uint) ([]*model.Account, error) {
	var accounts []*model.Account
	if err := s.db.WithContext(ctx).Where("shop_id = ?", shopID).Find(&accounts).Error; err != nil {
		return nil, err
	}
	return accounts, nil
}

// GetByEnterpriseID 根据企业 ID 查询账号列表
func (s *AccountStore) GetByEnterpriseID(ctx context.Context, enterpriseID uint) ([]*model.Account, error) {
	var accounts []*model.Account
	if err := s.db.WithContext(ctx).Where("enterprise_id = ?", enterpriseID).Find(&accounts).Error; err != nil {
		return nil, err
	}
	return accounts, nil
}

// Update 更新账号
func (s *AccountStore) Update(ctx context.Context, account *model.Account) error {
	return s.db.WithContext(ctx).Save(account).Error
}

// Delete 软删除账号
func (s *AccountStore) Delete(ctx context.Context, id uint) error {
	return s.db.WithContext(ctx).Delete(&model.Account{}, id).Error
}

// List 查询账号列表
func (s *AccountStore) List(ctx context.Context, opts *store.QueryOptions, filters map[string]interface{}) ([]*model.Account, int64, error) {
	var accounts []*model.Account
	var total int64

	query := s.db.WithContext(ctx).Model(&model.Account{})

	// 应用过滤条件
	if username, ok := filters["username"].(string); ok && username != "" {
		query = query.Where("username LIKE ?", "%"+username+"%")
	}
	if phone, ok := filters["phone"].(string); ok && phone != "" {
		query = query.Where("phone LIKE ?", "%"+phone+"%")
	}
	if userType, ok := filters["user_type"].(int); ok {
		query = query.Where("user_type = ?", userType)
	}
	if status, ok := filters["status"].(int); ok {
		query = query.Where("status = ?", status)
	}

	// 计算总数
	if err := query.Count(&total).Error; err != nil {
		return nil, 0, err
	}

	// 分页
	if opts == nil {
		opts = store.DefaultQueryOptions()
	}
	offset := (opts.Page - 1) * opts.PageSize
	query = query.Offset(offset).Limit(opts.PageSize)

	// 排序
	if opts.OrderBy != "" {
		query = query.Order(opts.OrderBy)
	}

	// 执行查询
	if err := query.Find(&accounts).Error; err != nil {
		return nil, 0, err
	}

	return accounts, total, nil
}

// GetSubordinateIDs 获取账号的所有可见账号 ID（包含自己）
// 废弃说明：账号层级关系已改为通过 Shop 表维护
// 新的数据权限过滤应该基于 ShopID，而非账号的 ParentID
// 使用 Redis 缓存优化性能，缓存 30 分钟
//
// 对于代理账号：查询该账号所属店铺及其下级店铺的所有账号
// 对于平台用户和超级管理员：返回空（在上层跳过过滤）
func (s *AccountStore) GetSubordinateIDs(ctx context.Context, accountID uint) ([]uint, error) {
	// 1. 尝试从 Redis 缓存读取
	cacheKey := constants.RedisAccountSubordinatesKey(accountID)
	cached, err := s.redis.Get(ctx, cacheKey).Result()
	if err == nil {
		var ids []uint
		if err := sonic.Unmarshal([]byte(cached), &ids); err == nil {
			return ids, nil
		}
	}

	// 2. 查询当前账号
	account, err := s.GetByID(ctx, accountID)
	if err != nil {
		return nil, err
	}

	// 3. 如果是代理账号，需要查询该店铺及下级店铺的所有账号
	var ids []uint
	if account.UserType == constants.UserTypeAgent && account.ShopID != nil {
		// 注意：这里需要 ShopStore 来查询店铺的下级
		// 但为了避免循环依赖，这个逻辑应该在 Service 层处理
		// Store 层只提供基础的数据访问能力
		// 暂时返回只包含自己的列表
		ids = []uint{accountID}
	} else {
		// 平台用户和超级管理员返回空列表（在 Service 层跳过过滤）
		ids = []uint{}
	}

	// 4. 写入 Redis 缓存（30 分钟过期）
	data, _ := sonic.Marshal(ids)
	s.redis.Set(ctx, cacheKey, data, 30*time.Minute)

	return ids, nil
}

// ClearSubordinatesCache 清除指定账号的下级 ID 缓存
func (s *AccountStore) ClearSubordinatesCache(ctx context.Context, accountID uint) error {
	cacheKey := constants.RedisAccountSubordinatesKey(accountID)
	return s.redis.Del(ctx, cacheKey).Err()
}

// ClearSubordinatesCacheForParents 递归清除所有上级账号的缓存
// 废弃说明：账号层级关系已改为通过 Shop 表维护
// 新版本应该清除店铺层级的缓存，而非账号层级
func (s *AccountStore) ClearSubordinatesCacheForParents(ctx context.Context, accountID uint) error {
	// 清除当前账号的缓存
	if err := s.ClearSubordinatesCache(ctx, accountID); err != nil {
		return err
	}

	// TODO: 应该清除该账号所属店铺及上级店铺的下级缓存
	// 但这需要访问 ShopStore，为了避免循环依赖，应在 Service 层处理

	return nil
}