import { useEffect, useCallback, useRef, useState } from 'react';
import { useDashboard } from '../components/context';
import useApiControl from './useApiControl';
import useLatestValue from './useLatestValue';

/**
 * 页面感知的API调用Hook
 * 扩展useApiControl，增加页面感知能力和过渡动画状态感知
 */
export function usePageAwareApi<T, P = any>(options: {
  apiFunction: (params: P) => Promise<T>,
  onSuccess?: (data: T, params: P) => void,
  onError?: (error: any, params: P) => void,
  formatParams?: (params: P) => P,
  defaultData?: any,
  errorRetryCount?: number,
  enableDebug?: boolean,
  apiName?: string,
  debounceTime?: number,
  cacheTime?: number,
  enableGlobalCache?: boolean,
  pageId: string, // 组件所属页面ID
  shouldSkipDuringTransition?: boolean, // 是否在过渡期跳过API调用，默认true
}) {
  const {
    pageId,
    shouldSkipDuringTransition = true,
    apiName,
    ...apiControlOptions
  } = options;

  // 获取当前活动页面信息和过渡状态
  const { activePage, isTransitioning } = useDashboard();
  
  // 使用refs存储最新的activePage和过渡状态，避免闭包问题
  const activePageRef = useLatestValue(activePage);
  const isTransitioningRef = useLatestValue(isTransitioning);
  
  // 跟踪是否已经在页面激活后调用过API
  const hasCalledAfterActivationRef = useRef(false);
  
  // 跟踪上一次页面活跃状态，用于检测页面激活状态变化
  const wasPageActiveRef = useRef(false);
  
  // 跟踪上一次调用的参数签名
  const lastParamsSignatureRef = useRef<string>('');
  
  // 跟踪是否已经注册了数据类型变更监听器
  const hasSetupListenersRef = useRef(false);
  
  // 创建一个setState以便触发渲染但不实际使用状态值
  const [_, forceRender] = useState(0);
  
  // 获取基础API控制对象
  const apiControl = useApiControl({
    ...apiControlOptions,
    apiName: `${apiName || 'API'}[${pageId}]`,
  });

  // 生成参数签名，用于去重
  const generateParamsSignature = useCallback((params: P): string => {
    return JSON.stringify(params);
  }, []);

  // 页面感知的callApi包装函数
  const callPageAwareApi = useCallback((params: P, customDebounceTime?: number) => {
    // 如果正在过渡动画中且配置为跳过，则不调用
    if (shouldSkipDuringTransition && isTransitioningRef.current) {
      console.log(`[${pageId}] 检测到页面过渡动画，暂停调用${apiName || 'API'}`);
      return;
    }
    
    // 检查当前页面是否是组件所属页面
    const currentActivePage = activePageRef.current;
    if (currentActivePage !== pageId) {
      console.log(`[${pageId}] 当前页面(${currentActivePage})不是组件所属页面，跳过API调用`);
      return;
    }
    
    // 生成参数签名用于去重
    const paramsSignature = generateParamsSignature(params);
    
    // 检查是否与上次参数相同
    const isParamsSame = paramsSignature === lastParamsSignatureRef.current;
    
    // 页面刚激活的情况下，忽略相同参数检查
    if (isParamsSame && hasCalledAfterActivationRef.current) {
      console.log(`[${pageId}] 参数未变化，跳过重复调用${apiName || 'API'}`);
      return;
    }
    
    // 更新已调用状态和参数签名
    hasCalledAfterActivationRef.current = true;
    lastParamsSignatureRef.current = paramsSignature;
    
    // 调用API
    console.log(`[${pageId}] 调用${apiName || 'API'}，参数:`, params);
    apiControl.callApi(params, customDebounceTime);
  }, [
    apiControl, pageId, apiName, activePageRef, isTransitioningRef, 
    shouldSkipDuringTransition, generateParamsSignature
  ]);

  // 直接调用版本，不经过防抖
  const callPageAwareApiImmediate = useCallback((params: P, ignoreCache = false) => {
    // 同样的页面和过渡检查
    if (shouldSkipDuringTransition && isTransitioningRef.current) {
      console.log(`[${pageId}] 检测到页面过渡动画，暂停立即调用${apiName || 'API'}`);
      return;
    }
    
    const currentActivePage = activePageRef.current;
    if (currentActivePage !== pageId) {
      console.log(`[${pageId}] 当前页面(${currentActivePage})不是组件所属页面，跳过立即API调用`);
      return;
    }
    
    // 更新已调用状态和参数签名
    hasCalledAfterActivationRef.current = true;
    lastParamsSignatureRef.current = generateParamsSignature(params);
    
    // 直接调用API
    console.log(`[${pageId}] 立即调用${apiName || 'API'}，参数:`, params);
    apiControl.callApiImmediate(params, ignoreCache);
  }, [
    apiControl, pageId, apiName, activePageRef, isTransitioningRef, 
    shouldSkipDuringTransition, generateParamsSignature
  ]);

  // 强制刷新方法，用于外部强制重新获取数据
  const forceRefresh = useCallback((params?: P) => {
    const currentActivePage = activePageRef.current;
    if (currentActivePage !== pageId) {
      console.log(`[${pageId}] 当前页面(${currentActivePage})不是组件所属页面，无法强制刷新`);
      return;
    }
    
    if (params) {
      // 重置参数签名，确保下次调用即使参数相同也会执行
      lastParamsSignatureRef.current = '';
      console.log(`[${pageId}] 强制刷新${apiName || 'API'}数据`);
      apiControl.callApiImmediate(params, true); // 忽略缓存，立即调用
    } else {
      // 重置参数签名，确保下次调用即使参数相同也会执行
      lastParamsSignatureRef.current = '';
      console.log(`[${pageId}] 重置API状态，等待下次调用`);
      // 触发重新渲染，确保组件的useEffect能感知到变化
      forceRender(prev => prev + 1);
    }
  }, [apiControl, pageId, activePageRef, apiName]);

  // 监听页面激活状态变化和数据类型变更
  useEffect(() => {
    // 当前页面是否是活跃页面
    const isPageActive = activePageRef.current === pageId;
    const wasPageActive = wasPageActiveRef.current;
    const isCurrentlyTransitioning = isTransitioningRef.current;
    
    // 检测页面从非活跃到活跃的变化（页面刚被切换到）
    if (isPageActive && !wasPageActive && !isCurrentlyTransitioning) {
      console.log(`[${pageId}] 页面从非活跃变为活跃状态，重置API状态`);
      // 重置参数签名，确保下次调用即使参数相同也会执行
      lastParamsSignatureRef.current = '';
      // 重置已调用标志，以便触发外部的useEffect
      hasCalledAfterActivationRef.current = false;
      // 触发重新渲染，确保组件的useEffect能感知到变化
      forceRender(prev => prev + 1);
    }
    
    // 仅在页面第一次激活时设置数据类型变更事件监听
    if (isPageActive && !hasSetupListenersRef.current) {
      console.log(`[${pageId}] 首次设置数据类型变更监听`);
      
      // 数据类型变更处理函数
      const handleDataTypeChange = () => {
        console.log(`[${pageId}] 检测到数据类型变更`);
        // 重置参数签名，确保下次调用即使参数相同也会执行
        lastParamsSignatureRef.current = '';
        // 触发重新渲染，确保组件的useEffect能感知到变化
        forceRender(prev => prev + 1);
      };
      
      // 添加事件监听
      window.addEventListener('mapDataTypeChange', handleDataTypeChange);
      hasSetupListenersRef.current = true;
      
      // 清理函数
      return () => {
        window.removeEventListener('mapDataTypeChange', handleDataTypeChange);
        hasSetupListenersRef.current = false;
      };
    }
    
    // 更新页面活跃状态记录
    wasPageActiveRef.current = isPageActive;
  }, [pageId, activePage, isTransitioning, activePageRef, isTransitioningRef]);

  // 创建包含页面感知API的控制对象
  return {
    ...apiControl,
    callApi: callPageAwareApi,
    callApiImmediate: callPageAwareApiImmediate,
    forceRefresh: forceRefresh,
    // 添加页面状态信息
    isPageActive: activePageRef.current === pageId,
    isTransitioning: isTransitioningRef.current,
    // 添加一个reset方法，用于直接重置内部状态
    resetCache: () => {
      lastParamsSignatureRef.current = '';
      hasCalledAfterActivationRef.current = false;
    },
    // 添加一个重置参数但不影响其他内部状态的方法
    resetParamsSignature: () => {
      lastParamsSignatureRef.current = '';
    }
  };
}

export default usePageAwareApi; 