/**
 * 级联数据源服务
 * 提供懒加载级联数据功能
 */
import request from '@/utils/request';
import { CascadeDataSourceType, type CascadeOption, type CascadeLevelConfig } from './types';
import { getCascadeDataSourceConfig } from './CascadeDataSourceRegistry';

/**
 * 级联数据源服务类
 */
class CascadeDataSourceService {
  /**
   * 判断配置是否为递归模式
   */
  private isRecursiveMode(config: any): boolean {
    return !!config.recursive;
  }

  /**
   * 加载第一级数据
   * @param type 级联数据源类型
   * @returns 第一级选项列表
   */
  async loadFirstLevel(type: CascadeDataSourceType): Promise<CascadeOption[]> {
    const config = getCascadeDataSourceConfig(type);

    if (!config) {
      console.error(`❌ 级联数据源类型 ${type} 未配置`);
      return [];
    }

    // 递归模式
    if (this.isRecursiveMode(config)) {
      return this.loadRecursiveLevel(config.recursive!, null);
    }

    // 固定层级模式
    if (!config.levels || config.levels.length === 0) {
      console.error(`❌ 级联数据源类型 ${type} 未配置层级`);
      return [];
    }

    return this.loadLevel(config.levels[0], null, config.levels.length > 1);
  }

  /**
   * 加载子级数据
   * @param type 级联数据源类型
   * @param selectedOptions 已选择的选项路径（如 [env1, project1]）
   * @returns 下一级选项列表
   */
  async loadChildren(
    type: CascadeDataSourceType,
    selectedOptions: any[]
  ): Promise<CascadeOption[]> {
    const config = getCascadeDataSourceConfig(type);

    if (!config) {
      console.error(`❌ 级联数据源类型 ${type} 未配置`);
      return [];
    }

    // 递归模式：使用同一配置加载所有层级
    if (this.isRecursiveMode(config)) {
      const parentValue = selectedOptions[selectedOptions.length - 1];
      return this.loadRecursiveLevel(config.recursive!, parentValue);
    }

    // 固定层级模式
    if (!config.levels) {
      console.error(`❌ 级联数据源类型 ${type} 未配置层级`);
      return [];
    }

    const levelIndex = selectedOptions.length;
    
    if (levelIndex >= config.levels.length) {
      console.warn(`⚠️ 级联层级 ${levelIndex} 超出配置范围`);
      return [];
    }

    const levelConfig = config.levels[levelIndex];
    const parentValue = selectedOptions[levelIndex - 1];
    const hasNextLevel = levelIndex + 1 < config.levels.length;

    return this.loadLevel(levelConfig, parentValue, hasNextLevel);
  }

  /**
   * 加载递归层级数据（无限层级）
   * @param recursiveConfig 递归配置
   * @param parentValue 父级值（null 表示加载根节点）
   * @returns 选项列表
   */
  private async loadRecursiveLevel(
    recursiveConfig: any,
    parentValue: any
  ): Promise<CascadeOption[]> {
    try {
      // 构建请求参数
      const params: Record<string, any> = { ...recursiveConfig.params };
      
      // 添加父级参数
      if (parentValue !== null) {
        params[recursiveConfig.parentParam] = parentValue;
      }

      // 发起请求
      const response = await request.get(recursiveConfig.url, { params });
      const data = response || [];

      // 转换为级联选项格式
      return data.map((item: any) => {
        const option: CascadeOption = {
          label: item[recursiveConfig.labelField],
          value: item[recursiveConfig.valueField]
        };

        // 判断是否为叶子节点
        if (recursiveConfig.hasChildren) {
          // 使用自定义判断函数
          option.isLeaf = !recursiveConfig.hasChildren(item);
        } else if ('isLeaf' in item) {
          // 使用后端返回的 isLeaf 字段
          option.isLeaf = item.isLeaf;
        } else if ('hasChildren' in item) {
          // 使用后端返回的 hasChildren 字段
          option.isLeaf = !item.hasChildren;
        } else {
          // 默认不是叶子节点（允许继续展开）
          option.isLeaf = false;
        }

        return option;
      });
    } catch (error) {
      console.error(`❌ 加载递归级联数据失败:`, error);
      return [];
    }
  }

  /**
   * 加载单个层级的数据（固定层级模式）
   * @param levelConfig 层级配置
   * @param parentValue 父级值
   * @param hasNextLevel 是否有下一级
   * @returns 选项列表
   */
  private async loadLevel(
    levelConfig: CascadeLevelConfig,
    parentValue: any,
    hasNextLevel: boolean
  ): Promise<CascadeOption[]> {
    try {
      // 构建请求参数
      const params: Record<string, any> = { ...levelConfig.params };
      
      // 如果有父级值且配置了父级参数名，添加到请求参数中
      if (parentValue !== null && levelConfig.parentParam) {
        params[levelConfig.parentParam] = parentValue;
      }

      // 发起请求
      const response = await request.get(levelConfig.url, { params });
      const data = response || [];

      // 转换为级联选项格式
      return data.map((item: any) => {
        const option: CascadeOption = {
          label: item[levelConfig.labelField],
          value: item[levelConfig.valueField]
        };

        // 判断是否为叶子节点
        if (levelConfig.isLeaf) {
          option.isLeaf = levelConfig.isLeaf(item);
        } else {
          // 如果没有下一级配置，则为叶子节点
          option.isLeaf = !hasNextLevel;
        }

        return option;
      });
    } catch (error) {
      console.error(`❌ 加载级联数据失败:`, error);
      return [];
    }
  }

  /**
   * 获取级联配置的层级数
   * @param type 级联数据源类型
   * @returns 层级数（递归模式返回 -1 表示无限层级）
   */
  getLevelCount(type: CascadeDataSourceType): number {
    const config = getCascadeDataSourceConfig(type);
    if (!config) return 0;
    
    // 递归模式返回 -1 表示无限层级
    if (this.isRecursiveMode(config)) {
      return -1;
    }
    
    return config.levels?.length || 0;
  }

  /**
   * 获取级联配置的描述
   * @param type 级联数据源类型
   * @returns 描述文本
   */
  getDescription(type: CascadeDataSourceType): string {
    const config = getCascadeDataSourceConfig(type);
    return config?.description || '';
  }
}

// 导出单例
export const cascadeDataSourceService = new CascadeDataSourceService();

// 向后兼容：导出函数式API
export const loadCascadeFirstLevel = (type: CascadeDataSourceType) =>
  cascadeDataSourceService.loadFirstLevel(type);

export const loadCascadeChildren = (type: CascadeDataSourceType, selectedOptions: any[]) =>
  cascadeDataSourceService.loadChildren(type, selectedOptions);

