/**
 * Zulip账号关联缓存配置
 *
 * 功能描述：
 * - 定义Zulip账号关联模块的缓存策略和配置
 * - 提供不同类型数据的缓存TTL设置
 * - 支持环境相关的缓存配置调整
 * - 提供缓存键命名规范和管理工具
 *
 * 职责分离：
 * - 缓存策略：定义不同数据类型的缓存时间和策略
 * - 键管理：提供统一的缓存键命名规范
 * - 环境适配：根据环境调整缓存配置
 * - 性能优化：平衡缓存效果和内存使用
 *
 * 最近修改：
 * - 2026-01-12: 初始创建 - 定义缓存配置和策略
 *
 * @author angjustinl
 * @version 1.0.0
 * @since 2026-01-12
 * @lastModified 2026-01-12
 */

import { CacheModuleOptions } from '@nestjs/cache-manager';

/**
 * 缓存配置常量
 */
export const CACHE_CONFIG = {
  // 缓存键前缀
  PREFIX: 'zulip_accounts',

  // TTL配置（秒）
  TTL: {
    // 账号基础信息缓存 - 5分钟
    ACCOUNT_INFO: 300,

    // 统计数据缓存 - 1分钟（变化频繁）
    STATISTICS: 60,

    // 验证状态缓存 - 10分钟
    VERIFICATION_STATUS: 600,

    // 错误账号列表缓存 - 2分钟（需要及时更新）
    ERROR_ACCOUNTS: 120,

    // 批量查询结果缓存 - 3分钟
    BATCH_QUERY: 180,
  },

  // 缓存大小限制
  MAX_ITEMS: {
    // 生产环境
    PRODUCTION: 5000,

    // 开发环境
    DEVELOPMENT: 1000,

    // 测试环境
    TEST: 500,
  },
} as const;

/**
 * 缓存键类型枚举
 */
export enum CacheKeyType {
  GAME_USER = 'game_user',
  ZULIP_USER = 'zulip_user',
  ZULIP_EMAIL = 'zulip_email',
  ACCOUNT_ID = 'account_id',
  STATISTICS = 'stats',
  VERIFICATION_LIST = 'verification_list',
  ERROR_LIST = 'error_list',
  BATCH_QUERY = 'batch_query',
}

/**
 * 缓存配置工厂
 */
export class ZulipAccountsCacheConfigFactory {
  /**
   * 创建缓存模块配置
   *
   * @param environment 环境名称
   * @returns 缓存模块配置
   */
  static createCacheConfig(environment: string = 'development'): CacheModuleOptions {
    const maxItems = this.getMaxItemsByEnvironment(environment);

    return {
      ttl: CACHE_CONFIG.TTL.ACCOUNT_INFO, // 默认TTL
      max: maxItems,
      // 可以添加更多配置，如存储引擎等
    };
  }

  /**
   * 根据环境获取最大缓存项数
   *
   * @param environment 环境名称
   * @returns 最大缓存项数
   * @private
   */
  private static getMaxItemsByEnvironment(environment: string): number {
    switch (environment) {
      case 'production':
        return CACHE_CONFIG.MAX_ITEMS.PRODUCTION;
      case 'test':
        return CACHE_CONFIG.MAX_ITEMS.TEST;
      default:
        return CACHE_CONFIG.MAX_ITEMS.DEVELOPMENT;
    }
  }

  /**
   * 构建缓存键
   *
   * @param type 缓存键类型
   * @param identifier 标识符
   * @param suffix 后缀（可选）
   * @returns 完整的缓存键
   */
  static buildCacheKey(
    type: CacheKeyType,
    identifier?: string | number,
    suffix?: string
  ): string {
    const parts = [CACHE_CONFIG.PREFIX, type.toString()];

    if (identifier !== undefined) {
      parts.push(String(identifier));
    }

    if (suffix) {
      parts.push(suffix);
    }

    return parts.join(':');
  }

  /**
   * 获取指定类型的TTL
   *
   * @param type 缓存键类型
   * @returns TTL（秒）
   */
  static getTTLByType(type: CacheKeyType): number {
    switch (type) {
      case CacheKeyType.STATISTICS:
        return CACHE_CONFIG.TTL.STATISTICS;
      case CacheKeyType.VERIFICATION_LIST:
        return CACHE_CONFIG.TTL.VERIFICATION_STATUS;
      case CacheKeyType.ERROR_LIST:
        return CACHE_CONFIG.TTL.ERROR_ACCOUNTS;
      case CacheKeyType.BATCH_QUERY:
        return CACHE_CONFIG.TTL.BATCH_QUERY;
      default:
        return CACHE_CONFIG.TTL.ACCOUNT_INFO;
    }
  }

  /**
   * 生成缓存键模式（用于批量删除）
   *
   * @param type 缓存键类型
   * @returns 缓存键模式
   */
  static getCacheKeyPattern(type: CacheKeyType): string {
    return `${CACHE_CONFIG.PREFIX}:${type}:*`;
  }
}

/**
 * 缓存管理工具类
 */
export class ZulipAccountsCacheManager {
  /**
   * 获取所有相关的缓存键（用于清除）
   *
   * @param gameUserId 游戏用户ID
   * @param zulipUserId Zulip用户ID
   * @param zulipEmail Zulip邮箱
   * @returns 相关的缓存键列表
   */
  static getRelatedCacheKeys(
    gameUserId?: string,
    zulipUserId?: number,
    zulipEmail?: string
  ): string[] {
    const keys: string[] = [];

    // 统计数据缓存（总是需要清除）
    keys.push(ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.STATISTICS));

    // 验证和错误列表缓存（可能受影响）
    keys.push(ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.VERIFICATION_LIST));
    keys.push(ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.ERROR_LIST));

    // 具体记录的缓存
    if (gameUserId) {
      keys.push(
        ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.GAME_USER, gameUserId),
        ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.GAME_USER, gameUserId, 'with_user')
      );
    }

    if (zulipUserId) {
      keys.push(
        ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.ZULIP_USER, zulipUserId),
        ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.ZULIP_USER, zulipUserId, 'with_user')
      );
    }

    if (zulipEmail) {
      keys.push(
        ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.ZULIP_EMAIL, zulipEmail),
        ZulipAccountsCacheConfigFactory.buildCacheKey(CacheKeyType.ZULIP_EMAIL, zulipEmail, 'with_user')
      );
    }

    return keys;
  }

  /**
   * 检查缓存键是否有效
   *
   * @param key 缓存键
   * @returns 是否有效
   */
  static isValidCacheKey(key: string): boolean {
    return key.startsWith(CACHE_CONFIG.PREFIX + ':');
  }

  /**
   * 解析缓存键
   *
   * @param key 缓存键
   * @returns 解析结果
   */
  static parseCacheKey(key: string): {
    prefix: string;
    type: string;
    identifier?: string;
    suffix?: string;
  } | null {
    if (!this.isValidCacheKey(key)) {
      return null;
    }

    const parts = key.split(':');
    return {
      prefix: parts[0],
      type: parts[1],
      identifier: parts[2],
      suffix: parts[3],
    };
  }
}