'use client';

import React, { createContext, useContext, useState, useEffect, useCallback, useMemo } from 'react';

// 区域类型
export type Region = 'CN' | 'US' | 'UAE';

// 区域配置
export interface RegionConfig {
  code: Region;
  name: string;
  nameEn: string;
  timezone: string;
  currency: string;
  locale: string;
  flag: string;
}

// 所有区域配置
export const REGION_CONFIGS: Record<Region, RegionConfig> = {
  CN: {
    code: 'CN',
    name: '中国',
    nameEn: 'China',
    timezone: 'Asia/Shanghai',
    currency: 'CNY',
    locale: 'zh-CN',
    flag: '🇨🇳',
  },
  US: {
    code: 'US',
    name: '美国',
    nameEn: 'United States',
    timezone: 'America/New_York',
    currency: 'USD',
    locale: 'en-US',
    flag: '🇺🇸',
  },
  UAE: {
    code: 'UAE',
    name: '阿联酋',
    nameEn: 'United Arab Emirates',
    timezone: 'Asia/Dubai',
    currency: 'AED',
    locale: 'ar-AE',
    flag: '🇦🇪',
  },
};

// 区域上下文类型
interface RegionContextType {
  // 当前区域
  currentRegion: Region;
  // 当前区域配置
  currentRegionConfig: RegionConfig;
  // 用户默认区域
  defaultRegion: Region;
  // 用户可访问的区域列表
  accessibleRegions: Region[];
  // 可访问区域的配置列表
  accessibleRegionConfigs: RegionConfig[];
  // 是否可以切换区域
  canSwitchRegion: boolean;
  // 当前区域的权限列表
  currentPermissions: string[];
  // 各区域的权限映射
  regionPermissions: Record<Region, string[]>;
  // 切换区域
  switchRegion: (region: Region) => void;
  // 重置到默认区域
  resetToDefaultRegion: () => void;
  // 设置用户区域信息（登录后调用）
  setUserRegions: (defaultRegion: Region, accessibleRegions: Region[], regionPermissions?: Record<Region, string[]>) => void;
  // 清除区域信息（登出时调用）
  clearRegions: () => void;
  // 检查当前区域是否有指定权限
  hasPermission: (permission: string) => boolean;
  // 检查当前区域是否有任一权限
  hasAnyPermission: (permissions: string[]) => boolean;
  // 检查当前区域是否有所有权限
  hasAllPermissions: (permissions: string[]) => boolean;
}

// 本地存储 Key
const STORAGE_KEY_CURRENT_REGION = 'ffoa_current_region';
const STORAGE_KEY_DEFAULT_REGION = 'ffoa_default_region';
const STORAGE_KEY_ACCESSIBLE_REGIONS = 'ffoa_accessible_regions';
const STORAGE_KEY_REGION_PERMISSIONS = 'ffoa_region_permissions';

// 创建上下文
const RegionContext = createContext<RegionContextType | undefined>(undefined);

// Provider 组件
export function RegionProvider({ children }: { children: React.ReactNode }) {
  const [currentRegion, setCurrentRegion] = useState<Region>('CN');
  const [defaultRegion, setDefaultRegion] = useState<Region>('CN');
  const [accessibleRegions, setAccessibleRegions] = useState<Region[]>(['CN']);
  const [regionPermissions, setRegionPermissions] = useState<Record<Region, string[]>>({
    CN: [],
    US: [],
    UAE: [],
  });
  const [isInitialized, setIsInitialized] = useState(false);

  // 从本地存储恢复状态
  useEffect(() => {
    if (typeof window !== 'undefined') {
      const storedCurrentRegion = localStorage.getItem(STORAGE_KEY_CURRENT_REGION) as Region | null;
      const storedDefaultRegion = localStorage.getItem(STORAGE_KEY_DEFAULT_REGION) as Region | null;
      const storedAccessibleRegions = localStorage.getItem(STORAGE_KEY_ACCESSIBLE_REGIONS);
      const storedRegionPermissions = localStorage.getItem(STORAGE_KEY_REGION_PERMISSIONS);

      if (storedDefaultRegion) {
        setDefaultRegion(storedDefaultRegion);
      }

      if (storedAccessibleRegions) {
        try {
          setAccessibleRegions(JSON.parse(storedAccessibleRegions));
        } catch {
          // ignore
        }
      }

      if (storedRegionPermissions) {
        try {
          setRegionPermissions(JSON.parse(storedRegionPermissions));
        } catch {
          // ignore
        }
      }

      if (storedCurrentRegion) {
        setCurrentRegion(storedCurrentRegion);
      } else if (storedDefaultRegion) {
        setCurrentRegion(storedDefaultRegion);
      }

      setIsInitialized(true);
    }
  }, []);

  // 切换区域
  const switchRegion = useCallback((region: Region) => {
    if (!accessibleRegions.includes(region)) {
      console.warn(`Cannot switch to region ${region}: no access`);
      return;
    }

    setCurrentRegion(region);
    if (typeof window !== 'undefined') {
      localStorage.setItem(STORAGE_KEY_CURRENT_REGION, region);
    }
    
    console.log(`Switched to region: ${region}, permissions:`, regionPermissions[region]?.length || 0);
  }, [accessibleRegions, regionPermissions]);

  // 重置到默认区域
  const resetToDefaultRegion = useCallback(() => {
    setCurrentRegion(defaultRegion);
    if (typeof window !== 'undefined') {
      localStorage.setItem(STORAGE_KEY_CURRENT_REGION, defaultRegion);
    }
  }, [defaultRegion]);

  // 设置用户区域信息（登录后调用）
  const setUserRegions = useCallback((
    newDefaultRegion: Region, 
    newAccessibleRegions: Region[],
    newRegionPermissions?: Record<Region, string[]>
  ) => {
    setDefaultRegion(newDefaultRegion);
    setAccessibleRegions(newAccessibleRegions);
    
    if (newRegionPermissions) {
      setRegionPermissions(newRegionPermissions);
    }
    
    // 如果当前区域不在可访问列表中，切换到默认区域
    if (!newAccessibleRegions.includes(currentRegion)) {
      setCurrentRegion(newDefaultRegion);
    }

    // 保存到本地存储
    if (typeof window !== 'undefined') {
      localStorage.setItem(STORAGE_KEY_DEFAULT_REGION, newDefaultRegion);
      localStorage.setItem(STORAGE_KEY_ACCESSIBLE_REGIONS, JSON.stringify(newAccessibleRegions));
      if (newRegionPermissions) {
        localStorage.setItem(STORAGE_KEY_REGION_PERMISSIONS, JSON.stringify(newRegionPermissions));
      }
      if (!newAccessibleRegions.includes(currentRegion)) {
        localStorage.setItem(STORAGE_KEY_CURRENT_REGION, newDefaultRegion);
      }
    }
  }, [currentRegion]);

  // 清除区域信息（登出时调用）
  const clearRegions = useCallback(() => {
    setCurrentRegion('CN');
    setDefaultRegion('CN');
    setAccessibleRegions(['CN']);
    setRegionPermissions({ CN: [], US: [], UAE: [] });

    if (typeof window !== 'undefined') {
      localStorage.removeItem(STORAGE_KEY_CURRENT_REGION);
      localStorage.removeItem(STORAGE_KEY_DEFAULT_REGION);
      localStorage.removeItem(STORAGE_KEY_ACCESSIBLE_REGIONS);
      localStorage.removeItem(STORAGE_KEY_REGION_PERMISSIONS);
    }
  }, []);

  // 当前区域的权限列表
  const currentPermissions = useMemo(() => {
    return regionPermissions[currentRegion] || [];
  }, [regionPermissions, currentRegion]);

  // 检查当前区域是否有指定权限
  const hasPermission = useCallback((permission: string): boolean => {
    const perms = regionPermissions[currentRegion] || [];
    
    // 直接匹配
    if (perms.includes(permission)) {
      return true;
    }
    
    // 通配符匹配
    const [resource, action] = permission.split(':');
    if (perms.includes(`${resource}:*`)) {
      return true;
    }
    if (perms.includes(`${resource}:*:${action}`)) {
      return true;
    }
    if (perms.includes('*:*')) {
      return true;
    }
    
    return false;
  }, [regionPermissions, currentRegion]);

  // 检查当前区域是否有任一权限
  const hasAnyPermission = useCallback((permissions: string[]): boolean => {
    return permissions.some(p => hasPermission(p));
  }, [hasPermission]);

  // 检查当前区域是否有所有权限
  const hasAllPermissions = useCallback((permissions: string[]): boolean => {
    return permissions.every(p => hasPermission(p));
  }, [hasPermission]);

  // 计算派生值
  const currentRegionConfig = REGION_CONFIGS[currentRegion];
  const accessibleRegionConfigs = accessibleRegions.map(r => REGION_CONFIGS[r]);
  const canSwitchRegion = accessibleRegions.length > 1;

  const value: RegionContextType = {
    currentRegion,
    currentRegionConfig,
    defaultRegion,
    accessibleRegions,
    accessibleRegionConfigs,
    canSwitchRegion,
    currentPermissions,
    regionPermissions,
    switchRegion,
    resetToDefaultRegion,
    setUserRegions,
    clearRegions,
    hasPermission,
    hasAnyPermission,
    hasAllPermissions,
  };

  // 等待初始化完成
  if (!isInitialized) {
    return null;
  }

  return (
    <RegionContext.Provider value={value}>
      {children}
    </RegionContext.Provider>
  );
}

// Hook
export function useRegion() {
  const context = useContext(RegionContext);
  if (context === undefined) {
    throw new Error('useRegion must be used within a RegionProvider');
  }
  return context;
}

// 获取当前区域（用于非 React 环境，如 API Client）
export function getCurrentRegion(): Region {
  if (typeof window === 'undefined') {
    return 'CN';
  }
  return (localStorage.getItem(STORAGE_KEY_CURRENT_REGION) as Region) || 'CN';
}

// 获取当前区域的权限（用于非 React 环境）
export function getCurrentRegionPermissions(): string[] {
  if (typeof window === 'undefined') {
    return [];
  }
  try {
    const regionPermissions = JSON.parse(localStorage.getItem(STORAGE_KEY_REGION_PERMISSIONS) || '{}');
    const currentRegion = getCurrentRegion();
    return regionPermissions[currentRegion] || [];
  } catch {
    return [];
  }
}