// src/index.ts
import { FlagInfo, FlagGroup, SearchOptions, StatsInfo } from './types';
import { flagGroups } from './data';

// 创建缓存以提高性能
const CACHE = {
  flagCodeMap: new Map<string, FlagInfo>(),
  allFlags: [] as FlagInfo[],
  regionMap: new Map<string, FlagInfo[]>(),
  initialized: false
};

// 初始化数据缓存
function initializeCache() {
  if (CACHE.initialized) return;
  
  flagGroups.forEach(group => {
    CACHE.regionMap.set(group.region, group.flags);
    group.flags.forEach(flag => {
      CACHE.flagCodeMap.set(flag.code, flag);
      CACHE.allFlags.push(flag);
    });
  });
  
  CACHE.initialized = true;
}

// 在模块加载时初始化缓存
initializeCache();

/**
 * 获取所有国旗分组数据
 * @returns 按地区分组的国旗集合
 */
export function groups(): FlagGroup[] {
  return flagGroups;
}

/**
 * 获取所有国旗列表（不分组）
 * @returns 所有国旗信息列表
 */
export function all(): FlagInfo[] {
  return CACHE.allFlags;
}

/**
 * 根据国家/地区代码获取国旗信息
 * @param code 国家/地区代码 (ISO 3166-1 alpha-2)
 * @returns 国旗信息，找不到则返回undefined
 */
export function get(code: string): FlagInfo | undefined {
  if (!code) return undefined;
  return CACHE.flagCodeMap.get(code.toUpperCase());
}

/**
 * 根据名称（中文或英文）搜索国旗
 * @param keyword 搜索关键词
 * @param options 搜索选项
 * @returns 匹配的国旗信息列表
 */
export function search(keyword: string, options: SearchOptions = {}): FlagInfo[] {
  if (!keyword) return [];
  
  const { exact = false, field = 'all' } = options;
  const lowerKeyword = keyword.toLowerCase();
  
  return CACHE.allFlags.filter(flag => {
    if (field === 'cnName' || field === 'all') {
      if (exact) {
        if (flag.cnName === keyword) return true;
      } else if (flag.cnName.toLowerCase().includes(lowerKeyword)) {
        return true;
      }
    }
    
    if (field === 'enName' || field === 'all') {
      if (exact) {
        if (flag.enName === keyword) return true;
      } else if (flag.enName.toLowerCase().includes(lowerKeyword)) {
        return true;
      }
    }
    
    if (field === 'code' || field === 'all') {
      const code = flag.code.toLowerCase();
      if (exact) {
        return code === lowerKeyword;
      } else if (code.includes(lowerKeyword)) {
        return true;
      }
    }
    
    return false;
  });
}

/**
 * 根据地区获取国旗列表
 * @param region 地区名称
 * @returns 该地区的国旗信息列表
 */
export function region(region: string): FlagInfo[] {
  return CACHE.regionMap.get(region) || [];
}

/**
 * 获取所有地区名称
 * @returns 地区名称列表
 */
export function regions(): string[] {
  return Array.from(CACHE.regionMap.keys());
}

/**
 * 获取随机国旗
 * @param count 获取数量，默认为1
 * @returns 随机国旗信息或列表
 */
export function random(count: number = 1): FlagInfo | FlagInfo[] {
  if (count <= 0) 
     count = 1;
  
  // Fisher-Yates 洗牌算法
  const shuffled = [...CACHE.allFlags];
  for (let i = shuffled.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
  }
  
  if (count === 1) {
    return shuffled[0];
  }
  
  return shuffled.slice(0, Math.min(count, CACHE.allFlags.length));
}

/**
 * 根据Unicode获取国旗
 * @param unicode Unicode编码
 * @returns 匹配的国旗信息
 */
export function byUnicode(unicode: string): FlagInfo | undefined {
  if (!unicode) return undefined;
  return CACHE.allFlags.find(flag => flag.unicode === unicode);
}

/**
 * 根据emoji获取国旗
 * @param emoji emoji字符
 * @returns 匹配的国旗信息
 */
export function byEmoji(emoji: string): FlagInfo | undefined {
  if (!emoji) return undefined;
  return CACHE.allFlags.find(flag => flag.flag === emoji);
}

/**
 * 根据自定义条件过滤国旗
 * @param predicate 过滤条件函数
 * @returns 匹配的国旗信息列表
 */
export function filter(predicate: (flag: FlagInfo) => boolean): FlagInfo[] {
  return CACHE.allFlags.filter(predicate);
}

/**
 * 获取国旗数据统计信息
 * @returns 统计信息
 */
export function stats(): StatsInfo {
  return {
    total: CACHE.allFlags.length,
    regions: flagGroups.map(group => ({
      region: group.region,
      count: group.flags.length
    }))
  };
}

// 默认导出
export default {
  groups,
  all,
  get,
  search,
  region,
  regions,
  random,
  byUnicode,
  byEmoji,
  filter,
  stats
};

// 测试示例

  function test() { 
    console.log('=== 国旗Emoji项目示例 ===');
  
  // 基本信息获取
  console.log('总国旗数:', all().length);
  console.log('地区数:', regions().length);
  
  // 获取特定国旗
  const china = get('CN');
  console.log('\n中国国旗:', china?.flag, china?.cnName);
  
  // 搜索功能
  const chinaSearch = search('中国', { exact: true });
  console.log('\n精确搜索"中国":', chinaSearch.map(f => f.cnName));
  
  const asiaSearch = search('亚');
  console.log('\n模糊搜索"亚" (前5个):', 
    asiaSearch.slice(0, 5).map(f => `${f.cnName} ${f.flag}`));
  
  // 地区查询
  const europeFlags = region('欧洲');
  console.log(`\n欧洲国家 (${europeFlags.length}个):`,
    europeFlags.slice(0, 5).map(f => f.cnName).join(', '));
  
  // 随机获取
  console.log('\n随机国旗:', random(1));
  console.log('随机3个国旗:', (random(3) as FlagInfo[]).map(f => f.flag));
  
  // 特殊查询
  const japanByEmoji = byEmoji('🇯🇵');
  console.log('\n通过emoji找日本:', japanByEmoji?.cnName);
  
  const usByUnicode = byUnicode('U+1F1FA U+1F1F8');
  console.log('通过Unicode找美国:', usByUnicode?.cnName);
  
  // 自定义过滤
  const northAmerican = filter(f => 
    f.cnName.includes('美') || f.enName.includes('America')
  );
  console.log('\n美洲国家:', northAmerican.map(f => f.cnName).join(', '));
  
  // 统计信息
  const statistics = stats();
  console.log('\n统计信息:');
  console.log(`  总数: ${statistics.total}`);
  console.log('  各地区分布:');
  statistics.regions.forEach(r => {
    console.log(`    ${r.region}: ${r.count}个`);
  });
  }
  // test();