/**
 * 级联选择器选项 Hook
 * 支持静态数据和预定义级联数据源
 */

import { useState, useEffect, useCallback } from 'react';
import type { FieldConfig, CascadeFieldOption } from '../types';
import {
  cascadeDataSourceService,
  CascadeDataSourceType,
  type CascadeOption
} from '@/domain/dataSource';

/**
 * 转换 CascadeOption 为 CascadeFieldOption
 */
const convertToCascadeFieldOption = (options: CascadeOption[]): CascadeFieldOption[] => {
  return options.map(opt => ({
    label: opt.label,
    value: opt.value,
    isLeaf: opt.isLeaf,
    children: opt.children ? convertToCascadeFieldOption(opt.children) : undefined
  }));
};

/**
 * 使用级联选择器选项
 * @param field 字段配置
 * @returns 级联选项列表
 */
export const useCascaderOptions = (field: FieldConfig): CascadeFieldOption[] => {
  const [options, setOptions] = useState<CascadeFieldOption[]>([]);

  useEffect(() => {
    // 如果是静态数据源，直接使用配置的选项
    if (field.dataSourceType === 'static' && field.cascadeOptions) {
      console.log('📊 使用静态级联数据:', field.cascadeOptions);
      setOptions(field.cascadeOptions);
      return;
    }

    // 如果是预定义级联数据源
    if (field.dataSourceType === 'predefined' && field.predefinedCascadeDataSource?.sourceType) {
      const sourceType = field.predefinedCascadeDataSource.sourceType as CascadeDataSourceType;
      
      console.log(`📡 加载预定义级联数据源: ${sourceType}`);
      
      // 加载第一级数据
      cascadeDataSourceService
        .loadFirstLevel(sourceType)
        .then(data => {
          console.log(`✅ 预定义级联数据源 ${sourceType} 第一级加载成功:`, data);
          setOptions(convertToCascadeFieldOption(data));
        })
        .catch(error => {
          console.error(`❌ 加载预定义级联数据源 ${sourceType} 失败:`, error);
          setOptions([]);
        });
    }
  }, [field.dataSourceType, field.cascadeOptions, field.predefinedCascadeDataSource]);

  return options;
};

/**
 * 懒加载级联子选项
 * 用于动态加载级联选择器的子级数据
 */
export const useCascaderLoadData = (field: FieldConfig) => {
  // 获取数据源类型（如果不是预定义类型，则为 null）
  const sourceType = field.dataSourceType === 'predefined' && field.predefinedCascadeDataSource?.sourceType
    ? (field.predefinedCascadeDataSource.sourceType as CascadeDataSourceType)
    : null;

  // 始终调用 useCallback，但在内部处理条件逻辑
  const loadData = useCallback(
    async (selectedOptions: any[]) => {
      // 如果不是预定义数据源，直接返回
      if (!sourceType) {
        return;
      }

      console.log(`🔄 懒加载级联数据: ${sourceType}, 已选择:`, selectedOptions);

      // 提取已选择的值
      const selectedValues = selectedOptions.map(opt => opt.value);

      // 获取目标选项（最后一个被选择的选项）
      const targetOption = selectedOptions[selectedOptions.length - 1];
      
      try {
        // 加载子级数据
        const childrenData = await cascadeDataSourceService.loadChildren(sourceType, selectedValues);
        console.log(`✅ 懒加载成功，子级数据:`, childrenData);

        // 转换为级联选项格式
        const children = convertToCascadeFieldOption(childrenData);
        
        // 更新最后一个选项的 children
        // 重要：需要设置 loading: false 和 children
        targetOption.loading = false;
        
        // 如果有子数据，设置 children；如果没有，设置为 undefined 并标记为叶子节点
        if (children && children.length > 0) {
          targetOption.children = children;
        } else {
          targetOption.children = undefined;
          targetOption.isLeaf = true;
        }
      } catch (error) {
        console.error(`❌ 懒加载失败:`, error);
        
        // 出错时标记为叶子节点（不再展开）
        targetOption.loading = false;
        targetOption.children = undefined;
        targetOption.isLeaf = true;
      }
    },
    [sourceType]
  );

  // 只有预定义级联数据源才返回懒加载函数，否则返回 undefined
  return sourceType ? loadData : undefined;
};

