/**
 * 页面动作指令解析与校验工具
 * 用于解析 Dify 返回的页面操作指令
 */

// Tab 枚举 - 仅包含 AdminPage 实际支持的 tabs
export type Tab = 
  | 'home'
  | 'products' 
  | 'transactions'
  | 'marketing'
  | 'aftersales';

// 子页面/功能别名（会映射到对应的主 Tab）
export type SubPage = 
  | 'orders' 
  | 'users' 
  | 'categories' 
  | 'brands' 
  | 'banners' 
  | 'coupons'
  | 'coupon_create'
  | 'product_create';

// 页面动作类型
export type PageActionType = 
  | 'navigate' 
  | 'navigate_to_page'  // 直接路由跳转
  | 'filter' 
  | 'sort' 
  | 'search' 
  | 'set_page_state';

// 页面动作接口
export interface PageAction {
  kind: 'page_action';
  type: PageActionType;
  params: PageActionParams;
}

// 各类型参数定义
export interface NavigateParams {
  tab: Tab;
}

export interface SearchParams {
  tab: Tab;
  keyword: string;
}

export interface SortParams {
  tab: Tab;
  field: string;
  direction: 'asc' | 'desc';
}

export interface FilterParams {
  tab: Tab;
  filters: Record<string, any>;
}

export interface SetPageStateParams {
  tab: Tab;
  filters?: Record<string, any>;
  sort?: { field: string; direction: 'asc' | 'desc' };
  search?: string;
}

export type PageActionParams = 
  | NavigateParams 
  | SearchParams 
  | SortParams 
  | FilterParams 
  | SetPageStateParams;

// Tab 别名映射（用于标准化）- 映射到 AdminPage 支持的 tabs
const TAB_ALIASES: Record<string, Tab> = {
  // 主 tabs
  'home': 'home',
  '首页': 'home',
  'products': 'products',
  'product': 'products',
  '商品': 'products',
  '商品管理': 'products',
  'transactions': 'transactions',
  'finance': 'transactions',
  '财务': 'transactions',
  '财务管理': 'transactions',
  'marketing': 'marketing',
  '营销': 'marketing',
  '营销管理': 'marketing',
  'aftersales': 'aftersales',
  'after_sales': 'aftersales',
  'afterSales': 'aftersales',
  '售后': 'aftersales',
  '售后管理': 'aftersales',
  
  // 子功能映射到主 Tab
  'orders': 'transactions',
  'order': 'transactions',
  '订单': 'transactions',
  '订单管理': 'transactions',
  'users': 'home',
  'user': 'home',
  '用户': 'home',
  '用户管理': 'home',
  'categories': 'products',
  'category': 'products',
  '分类': 'products',
  '分类管理': 'products',
  'brands': 'products',
  'brand': 'products',
  '品牌': 'products',
  '品牌管理': 'products',
  'banners': 'marketing',
  'banner': 'marketing',
  '轮播图': 'marketing',
  'coupons': 'marketing',
  'coupon': 'marketing',
  '优惠券': 'marketing',
  '优惠券管理': 'marketing',
  '折扣券': 'marketing',
  '折扣券管理': 'marketing',
};

// 特殊页面路由映射
export const SPECIAL_PAGE_ROUTES: Record<string, string> = {
  'coupon_create': '/admin/coupons/new',
  '创建优惠券': '/admin/coupons/new',
  '创建折扣券': '/admin/coupons/new',
  '新建优惠券': '/admin/coupons/new',
  '新建折扣券': '/admin/coupons/new',
  'product_create': '/admin/products/new',
  '创建商品': '/admin/products/new',
  '新建商品': '/admin/products/new',
};

// 有效的 Tab 列表
const VALID_TABS: Tab[] = [
  'home', 'products', 'transactions', 'marketing', 'aftersales'
];

/**
 * 标准化 Tab 名称
 */
export function normalizeTab(t: string): Tab | null {
  const normalized = t?.toLowerCase?.().trim();
  if (!normalized) return null;
  
  // 直接匹配
  if (VALID_TABS.includes(normalized as Tab)) {
    return normalized as Tab;
  }
  
  // 别名匹配
  if (TAB_ALIASES[t]) {
    return TAB_ALIASES[t];
  }
  
  if (TAB_ALIASES[normalized]) {
    return TAB_ALIASES[normalized];
  }
  
  return null;
}

/**
 * 从文本中提取页面动作
 * 支持两种格式：
 * 1. 标记块：[PAGE_ACTION]{...}[/PAGE_ACTION]
 * 2. 标准 JSON 对象：{"kind":"page_action",...}
 */
export function extractPageAction(text: string): PageAction | null {
  if (!text || typeof text !== 'string') return null;

  // 优先解析标记块格式
  const blockMatch = text.match(/\[PAGE_ACTION\]([\s\S]*?)\[\/PAGE_ACTION\]/i);
  if (blockMatch) {
    try {
      const parsed = JSON.parse(blockMatch[1].trim());
      return normalizePageAction(parsed);
    } catch (e) {
      console.warn('解析 PAGE_ACTION 标记块失败:', e);
    }
  }

  // 尝试从 metadata 中提取
  try {
    const metadataMatch = text.match(/"metadata"\s*:\s*(\{[\s\S]*?\}(?=\s*[,}]|$))/);
    if (metadataMatch) {
      const metadata = JSON.parse(metadataMatch[1]);
      if (metadata.actions && Array.isArray(metadata.actions)) {
        for (const action of metadata.actions) {
          if (isPageActionType(action.type)) {
            return normalizePageAction({
              kind: 'page_action',
              type: action.type,
              params: action.params || action,
            });
          }
        }
      }
    }
  } catch (e) {
    // 继续尝试其他格式
  }

  // 尝试解析整个文本为 JSON
  try {
    const parsed = JSON.parse(text);
    
    // 检查是否直接是 page_action
    if (parsed.kind === 'page_action') {
      return normalizePageAction(parsed);
    }
    
    // 检查是否在 actions 数组中
    if (parsed.actions && Array.isArray(parsed.actions)) {
      for (const action of parsed.actions) {
        if (isPageActionType(action.type)) {
          return normalizePageAction({
            kind: 'page_action',
            type: action.type,
            params: action.params || action,
          });
        }
      }
    }

    // 检查 metadata.actions
    if (parsed.metadata?.actions && Array.isArray(parsed.metadata.actions)) {
      for (const action of parsed.metadata.actions) {
        if (isPageActionType(action.type)) {
          return normalizePageAction({
            kind: 'page_action',
            type: action.type,
            params: action.params || action,
          });
        }
      }
    }
  } catch (e) {
    // 不是有效 JSON，继续尝试其他格式
  }

  // 尝试查找嵌入的 JSON 对象
  const jsonMatch = text.match(/\{[^{}]*"kind"\s*:\s*"page_action"[^{}]*\}/);
  if (jsonMatch) {
    try {
      const parsed = JSON.parse(jsonMatch[0]);
      return normalizePageAction(parsed);
    } catch (e) {
      // 忽略
    }
  }

  // 尝试查找 type 为页面动作的 JSON
  const actionTypes: PageActionType[] = ['navigate', 'filter', 'sort', 'search', 'set_page_state'];
  for (const actionType of actionTypes) {
    const pattern = new RegExp(`\\{[^{}]*"type"\\s*:\\s*"${actionType}"[^{}]*\\}`, 'g');
    const matches = text.match(pattern);
    if (matches) {
      for (const match of matches) {
        try {
          const parsed = JSON.parse(match);
          if (parsed.type === actionType) {
            return normalizePageAction({
              kind: 'page_action',
              type: actionType,
              params: parsed.params || parsed,
            });
          }
        } catch (e) {
          // 继续尝试
        }
      }
    }
  }

  return null;
}

/**
 * 检查是否为页面动作类型
 */
function isPageActionType(type: string): type is PageActionType {
  return ['navigate', 'navigate_to_page', 'filter', 'sort', 'search', 'set_page_state'].includes(type);
}

/**
 * 标准化页面动作对象
 */
function normalizePageAction(raw: any): PageAction | null {
  if (!raw || typeof raw !== 'object') return null;

  const type = raw.type as PageActionType;
  if (!isPageActionType(type)) return null;

  const params = raw.params || raw;
  
  // navigate_to_page 类型需要 path，其他类型需要 tab
  if (type === 'navigate_to_page') {
    const path = params.path;
    if (!path) return null;
    
    return {
      kind: 'page_action',
      type,
      params: { path } as any,
    };
  }
  
  // 其他类型需要 tab
  const tab = normalizeTab(params.tab);
  if (!tab) return null;

  const normalizedParams: any = { tab };

  switch (type) {
    case 'navigate':
      break;
    case 'search':
      normalizedParams.keyword = params.keyword || params.search || '';
      break;
    case 'sort':
      normalizedParams.field = params.field || 'created_at';
      normalizedParams.direction = params.direction === 'asc' ? 'asc' : 'desc';
      break;
    case 'filter':
      normalizedParams.filters = params.filters || {};
      break;
    case 'set_page_state':
      if (params.filters) normalizedParams.filters = params.filters;
      if (params.sort) normalizedParams.sort = params.sort;
      if (params.search !== undefined) normalizedParams.search = params.search;
      break;
  }

  return {
    kind: 'page_action',
    type,
    params: normalizedParams,
  };
}

/**
 * 校验页面动作是否完整
 */
export interface ValidationResult {
  ok: boolean;
  missing?: string[];
  warnings?: string[];
}

export function validatePageAction(action: PageAction): ValidationResult {
  const missing: string[] = [];
  const warnings: string[] = [];

  if (!action.type) {
    missing.push('type');
  }

  if (!action.params) {
    missing.push('params');
    return { ok: false, missing };
  }

  const params = action.params as any;

  // navigate_to_page 需要 path，其他类型需要 tab
  if (action.type === 'navigate_to_page') {
    if (!params.path) {
      missing.push('path');
    }
  } else {
    if (!params.tab) {
      missing.push('tab');
    }
  }

  switch (action.type) {
    case 'navigate_to_page':
      // 已在上面验证 path
      break;
    case 'search':
      if (!params.keyword && params.keyword !== '') {
        warnings.push('keyword 为空，将清除搜索');
      }
      break;
    case 'sort':
      if (!params.field) {
        missing.push('field');
      }
      if (!params.direction) {
        warnings.push('direction 未指定，默认使用 desc');
      }
      break;
    case 'filter':
      if (!params.filters || Object.keys(params.filters).length === 0) {
        warnings.push('filters 为空，将清除所有过滤条件');
      }
      break;
    case 'set_page_state':
      if (!params.filters && !params.sort && params.search === undefined) {
        warnings.push('未指定任何状态更新');
      }
      break;
  }

  return {
    ok: missing.length === 0,
    missing: missing.length > 0 ? missing : undefined,
    warnings: warnings.length > 0 ? warnings : undefined,
  };
}

/**
 * 获取动作类型的中文描述
 */
export function getActionTypeLabel(type: PageActionType): string {
  const labels: Record<PageActionType, string> = {
    navigate: '导航',
    navigate_to_page: '页面跳转',
    filter: '筛选',
    sort: '排序',
    search: '搜索',
    set_page_state: '设置页面状态',
  };
  return labels[type] || type;
}

/**
 * 获取 Tab 的中文描述
 */
export function getTabLabel(tab: Tab): string {
  const labels: Record<Tab, string> = {
    home: '首页',
    products: '商品管理',
    transactions: '财务管理',
    marketing: '营销管理',
    aftersales: '售后管理',
  };
  return labels[tab] || tab;
}
