import { useState, useRef, useCallback, useEffect } from 'react';

// 全局请求缓存，用于跨组件请求去重
const globalRequestCache: Record<string, {
  timestamp: number,
  params: any,
  controller: AbortController | null,
  lastResult?: any
}> = {};

/**
 * 日期格式化工具函数
 */
export const formatDateTime = (dateStr: string, isEndTime: boolean = false) => {
  if (!dateStr) return '';
  
  // 如果已经包含时间部分，直接返回
  if (dateStr.includes(':')) return dateStr;
  
  // 否则添加时间部分
  const timeStr = isEndTime ? '23:59:59' : '00:00:00';
  
  if (dateStr.includes('T')) {
    const dateOnly = dateStr.split('T')[0];
    return `${dateOnly} ${timeStr}`;
  } else if (dateStr.includes('-')) {
    return `${dateStr} ${timeStr}`;
  }
  
  return '';
};

/**
 * 标准化对象，消除属性顺序导致的差异
 * 用于更可靠地比较对象参数是否相等
 */
const normalizeObject = (obj: any): any => {
  // 如果不是对象或是null，直接返回
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    return obj;
  }
  
  // 对对象属性排序并递归处理值
  const sortedEntries = Object.entries(obj)
    .filter(([_, value]) => value !== undefined) // 移除undefined值
    .sort(([keyA], [keyB]) => keyA.localeCompare(keyB))
    .map(([key, value]) => [key, normalizeObject(value)]);
  
  return Object.fromEntries(sortedEntries);
};

/**
 * 生成请求签名，用于请求去重
 */
const generateRequestSignature = (apiName: string, params: any): string => {
  const normalizedParams = normalizeObject(params);
  return `${apiName}:${JSON.stringify(normalizedParams)}`;
};

/**
 * API调用控制钩子
 * 集中处理API调用的控制逻辑，如防抖、防重、错误处理等
 */
export function useApiControl<T, P = any>(options: {
  apiFunction: (params: P) => Promise<T>, // 实际API调用函数
  onSuccess?: (data: T, params: P) => void, // 成功回调
  onError?: (error: any, params: P) => void, // 错误回调
  formatParams?: (params: P) => P,       // 参数预处理函数
  defaultData?: any,                     // 默认数据
  errorRetryCount?: number,              // 错误重试次数
  enableDebug?: boolean,                 // 是否启用调试日志
  apiName?: string,                      // API名称（用于日志和缓存标识）
  debounceTime?: number,                 // 默认防抖时间
  cacheTime?: number,                    // 缓存结果的时间（毫秒），设为0禁用缓存
  enableGlobalCache?: boolean,           // 是否启用全局缓存
}) {
  const {
    apiFunction,
    onSuccess,
    onError,
    formatParams,
    defaultData = null,
    errorRetryCount = 3,
    enableDebug = false,
    apiName = 'API',
    debounceTime = 300,
    cacheTime = 1000,  // 默认缓存1秒
    enableGlobalCache = true,
  } = options;

  // 状态
  const [data, setData] = useState<any>(defaultData);
  const [loading, setLoading] = useState<boolean>(false);
  const [error, setError] = useState<any>(null);
  // 添加内部版本号状态，用于强制触发组件更新
  const [resetVersion, setResetVersion] = useState<number>(0);

  // 引用
  const errorCountRef = useRef<number>(0);
  const isRequestingRef = useRef<boolean>(false);
  const lastParamsRef = useRef<string>('');
  const paramsRef = useRef<P | null>(null);
  const componentIdRef = useRef<string>(`${apiName}_${Math.random().toString(36).substring(2, 9)}`);
  const abortControllerRef = useRef<AbortController | null>(null);
  const timerRef = useRef<any>(null);
  const mountedRef = useRef<boolean>(true);

  // 设置组件挂载状态
  useEffect(() => {
    mountedRef.current = true;
    return () => {
      mountedRef.current = false;
      
      // 组件卸载时取消所有未完成的请求
      if (abortControllerRef.current) {
        abortControllerRef.current.abort();
      }
      
      // 清除所有定时器
      if (timerRef.current) {
        clearTimeout(timerRef.current);
      }
    };
  }, []);

  // 日志函数
  const log = useCallback((message: string, data?: any) => {
    if (enableDebug) {
      console.log(`${apiName}:${componentIdRef.current.substring(0, 4)}: ${message}`, data || '');
    }
  }, [enableDebug, apiName]);

  // 检查是否存在相同请求的缓存结果
  const checkCache = useCallback((signature: string): { hasCachedResult: boolean, result?: any } => {
    if (!enableGlobalCache || cacheTime <= 0) {
      return { hasCachedResult: false };
    }
    
    const cachedRequest = globalRequestCache[signature];
    if (!cachedRequest) {
      return { hasCachedResult: false };
    }
    
    const now = Date.now();
    const isStillValid = (now - cachedRequest.timestamp) < cacheTime;
    
    if (isStillValid && cachedRequest.lastResult !== undefined) {
      log('使用缓存结果', cachedRequest.lastResult);
      return { hasCachedResult: true, result: cachedRequest.lastResult };
    }
    
    return { hasCachedResult: false };
  }, [enableGlobalCache, cacheTime, log]);

  // 中止之前的请求
  const abortPreviousRequest = useCallback(() => {
    if (abortControllerRef.current) {
      log('中止之前的请求');
      abortControllerRef.current.abort();
      abortControllerRef.current = null;
    }
  }, [log]);

  // 执行API调用
  const executeCall = useCallback(async (params: P, ignoreCache = false) => {
    // 如果组件已卸载，不执行任何操作
    if (!mountedRef.current) {
      log('组件已卸载，取消请求');
      return;
    }
    
    // 预处理参数
    const processedParams = formatParams ? formatParams(params) : params;
    
    // 生成请求签名
    const requestSignature = generateRequestSignature(apiName, processedParams);
    
    // 如果参数未变化且不忽略缓存，跳过请求
    if (requestSignature === lastParamsRef.current && !ignoreCache) {
      log('参数未变化，跳过请求', processedParams);
      return;
    }
    
    // 检查缓存
    if (!ignoreCache) {
      const { hasCachedResult, result } = checkCache(requestSignature);
      if (hasCachedResult && result !== undefined) {
        setData(result);
        if (onSuccess && mountedRef.current) {
          onSuccess(result, processedParams);
        }
        return;
      }
    }
    
    // 中止之前的请求
    abortPreviousRequest();
    
    // 记录本次请求参数
    lastParamsRef.current = requestSignature;
    paramsRef.current = processedParams as P;
    
    // 如果已经在请求中，跳过
    if (isRequestingRef.current) {
      log('已有请求正在进行中，更新请求参数');
      return;
    }
    
    // 如果错误次数超过最大重试次数，跳过
    if (errorCountRef.current >= errorRetryCount) {
      log(`已达到最大错误重试次数(${errorRetryCount})，停止请求`);
      return;
    }
    
    // 设置请求状态
    isRequestingRef.current = true;
    setLoading(true);
    setError(null);
    
    // 创建请求控制器
    abortControllerRef.current = new AbortController();
    
    // 更新全局请求缓存
    if (enableGlobalCache) {
      globalRequestCache[requestSignature] = {
        timestamp: Date.now(),
        params: processedParams,
        controller: abortControllerRef.current
      };
    }
    
    log('开始请求', processedParams);

    try {
      // 执行API调用
      const result = await apiFunction(processedParams);
      
      // 如果请求已被取消或组件已卸载，不继续处理
      if (abortControllerRef.current?.signal.aborted || !mountedRef.current) {
        log('请求已被取消或组件已卸载，忽略结果');
        return;
      }
      
      // 更新全局缓存的结果
      if (enableGlobalCache && globalRequestCache[requestSignature]) {
        globalRequestCache[requestSignature].lastResult = result;
        globalRequestCache[requestSignature].timestamp = Date.now();
      }
      
      // 重置错误计数
      errorCountRef.current = 0;
      
      // 设置数据
      if (mountedRef.current) {
        setData(result);
        
        // 调用成功回调
        if (onSuccess) {
          onSuccess(result, processedParams);
        }
      }
      
      log('请求成功', result);
    } catch (err: any) {
      // 如果是被中止的请求，不处理错误
      if (err.name === 'AbortError') {
        log('请求被中止');
        return;
      }
      
      // 如果组件已卸载，不处理错误
      if (!mountedRef.current) {
        return;
      }
      
      // 增加错误计数
      errorCountRef.current += 1;
      
      // 设置错误状态
      setError(err);
      
      // 调用错误回调
      if (onError) {
        onError(err, processedParams);
      }
      
      log('请求失败', err);
    } finally {
      // 如果组件仍然挂载，重置请求状态
      if (mountedRef.current) {
        isRequestingRef.current = false;
        setLoading(false);
      }
      
      // 清除abort controller
      abortControllerRef.current = null;
    }
  }, [
    apiFunction, 
    formatParams, 
    onSuccess, 
    onError, 
    errorRetryCount, 
    log,
    checkCache,
    abortPreviousRequest,
    apiName,
    enableGlobalCache
  ]);

  // 带防抖的执行函数
  const callApi = useCallback((params: P, customDebounceTime?: number) => {
    // 清除之前的定时器
    if (timerRef.current) {
      clearTimeout(timerRef.current);
    }

    // 设置新的定时器
    timerRef.current = setTimeout(() => {
      executeCall(params);
      timerRef.current = null;
    }, customDebounceTime ?? debounceTime);
  }, [executeCall, debounceTime]);

  // 立即执行API调用
  const callApiImmediate = useCallback((params: P, ignoreCache = false) => {
    // 清除之前的定时器
    if (timerRef.current) {
      clearTimeout(timerRef.current);
      timerRef.current = null;
    }

    // 立即执行
    executeCall(params, ignoreCache);
  }, [executeCall]);

  // 重试上一次请求
  const retry = useCallback(() => {
    if (paramsRef.current) {
      log('重试上一次请求', paramsRef.current);
      executeCall(paramsRef.current, true); // 忽略缓存重新执行
    } else {
      log('没有可重试的请求');
    }
  }, [executeCall, log]);

  // 清除特定API的全局缓存
  const clearCache = useCallback(() => {
    if (enableGlobalCache) {
      // 清除与当前API相关的所有缓存条目
      Object.keys(globalRequestCache).forEach(key => {
        if (key.startsWith(`${apiName}:`)) {
          delete globalRequestCache[key];
        }
      });
      log('已清除API相关的全局缓存');
    }
  }, [apiName, enableGlobalCache, log]);

  // 重置状态
  const reset = useCallback(() => {
    // 取消活跃的请求
    abortPreviousRequest();
    
    // 清除定时器
    if (timerRef.current) {
      clearTimeout(timerRef.current);
      timerRef.current = null;
    }
    
    // 重置所有状态
    errorCountRef.current = 0;
    isRequestingRef.current = false;
    lastParamsRef.current = '';
    paramsRef.current = null;
    
    if (mountedRef.current) {
      setData(defaultData);
      setLoading(false);
      setError(null);
      // 更新重置版本号，触发组件重新渲染
      setResetVersion(v => v + 1);
    }
    
    log('状态已重置');
  }, [defaultData, log, abortPreviousRequest]);

  // 创建一个稳定的引用，避免每次渲染返回新对象
  const stableApiControlRef = useRef<any>(null);
  if (stableApiControlRef.current === null) {
    stableApiControlRef.current = {};
  }
  
  // 更新引用对象的属性而不是创建新对象
  const apiControl = stableApiControlRef.current;
  apiControl.data = data;
  apiControl.loading = loading;
  apiControl.error = error;
  apiControl.callApi = callApi;
  apiControl.callApiImmediate = callApiImmediate;
  apiControl.retry = retry;
  apiControl.reset = reset;
  apiControl.clearCache = clearCache;
  apiControl.isRequesting = isRequestingRef.current;
  apiControl.hasError = error !== null;
  // 将重置版本号附加到apiControl对象，确保reset调用后组件能检测到变化
  apiControl.__resetVersion = resetVersion;

  // 返回稳定引用
  return apiControl;
}

/**
 * 日期参数格式化
 */
export function useDateParamFormatter() {
  const formatDateParams = useCallback((params: any) => {
    const formattedParams = { ...params };
    
    // 确保开始时间包含时分秒
    if (formattedParams.startTime) {
      formattedParams.startTime = formatDateTime(formattedParams.startTime);
    }
    
    // 确保结束时间包含时分秒
    if (formattedParams.endTime) {
      formattedParams.endTime = formatDateTime(formattedParams.endTime, true);
    }
    
    // 处理customizeStart和customizeEnd（部分API使用这些字段名）
    if (formattedParams.customizeStart) {
      formattedParams.customizeStart = formatDateTime(formattedParams.customizeStart);
    }
    
    if (formattedParams.customizeEnd) {
      formattedParams.customizeEnd = formatDateTime(formattedParams.customizeEnd, true);
    }
    
    return formattedParams;
  }, []);

  return { formatDateParams };
}

export default useApiControl; 