import { BackgroundTaskType as BackgroundTask, backgroundTaskManager, TaskStatusType as TaskStatus } from '@/services/backgroundTaskManager';
import * as BackgroundFetch from 'expo-background-fetch';
import { useCallback, useEffect, useState } from 'react';

export interface UseBackgroundTasksReturn {
  // 状态
  isInitialized: boolean;
  taskStatuses: TaskStatus[];
  registeredTasks: BackgroundTask[];
  
  // 方法
  registerTask: (task: BackgroundTask) => Promise<void>;
  unregisterTask: (taskId: string) => Promise<void>;
  executeTask: (taskId: string, data?: any) => Promise<void>;
  executeAllTasks: () => Promise<{ [taskId: string]: 'success' | 'failed' }>;
  getTaskStatus: (taskId: string) => TaskStatus | undefined;
  cleanupTaskStatuses: () => Promise<void>;
  
  // 后台任务状态
  backgroundTaskStatus: BackgroundFetch.BackgroundFetchStatus | null;
  getBackgroundTaskStatus: () => Promise<void>;
}

export const useBackgroundTasks = (): UseBackgroundTasksReturn => {
  const [isInitialized, setIsInitialized] = useState(false);
  const [taskStatuses, setTaskStatuses] = useState<TaskStatus[]>([]);
  const [registeredTasks, setRegisteredTasks] = useState<BackgroundTask[]>([]);
  const [backgroundTaskStatus, setBackgroundTaskStatus] = useState<BackgroundFetch.BackgroundFetchStatus | null>(null);

  // 初始化
  useEffect(() => {
    const initialize = async () => {
      try {
        await backgroundTaskManager.initialize();
        setIsInitialized(true);
        refreshData();
      } catch (error) {
        console.error('初始化后台任务失败:', error);
      }
    };

    initialize();
  }, []);

  // 刷新数据
  const refreshData = useCallback(() => {
    setTaskStatuses(backgroundTaskManager.getAllTaskStatuses());
    setRegisteredTasks(backgroundTaskManager.getRegisteredTasks());
  }, []);

  // 注册任务
  const registerTask = useCallback(async (task: BackgroundTask) => {
    await backgroundTaskManager.registerTask(task);
    refreshData();
  }, [refreshData]);

  // 取消注册任务
  const unregisterTask = useCallback(async (taskId: string) => {
    await backgroundTaskManager.unregisterTask(taskId);
    refreshData();
  }, [refreshData]);

  // 执行任务
  const executeTask = useCallback(async (taskId: string, data?: any) => {
    await backgroundTaskManager.executeTask(taskId, data);
    refreshData();
  }, [refreshData]);

  // 执行所有任务
  const executeAllTasks = useCallback(async () => {
    const results = await backgroundTaskManager.executeAllTasks();
    refreshData();
    return results;
  }, [refreshData]);

  // 获取任务状态
  const getTaskStatus = useCallback((taskId: string) => {
    return backgroundTaskManager.getTaskStatus(taskId);
  }, []);

  // 清理任务状态
  const cleanupTaskStatuses = useCallback(async () => {
    await backgroundTaskManager.cleanupTaskStatuses();
    refreshData();
  }, [refreshData]);

  // 获取后台任务状态
  const getBackgroundTaskStatus = useCallback(async () => {
    try {
      const status = await backgroundTaskManager.getBackgroundTaskStatus();
      setBackgroundTaskStatus(status);
    } catch (error) {
      console.error('获取后台任务状态失败:', error);
    }
  }, []);

  return {
    isInitialized,
    taskStatuses,
    registeredTasks,
    registerTask,
    unregisterTask,
    executeTask,
    executeAllTasks,
    getTaskStatus,
    cleanupTaskStatuses,
    backgroundTaskStatus,
    getBackgroundTaskStatus,
  };
};