// import { API_BASE_URL } from '../config/api-config';

// 交叉评查任务状态枚举
export enum CrossCheckingTaskStatus {
  PENDING = 'pending',
  IN_PROGRESS = 'in_progress', 
  COMPLETED = 'completed'
}

// 交叉评查任务类型枚举
export enum CrossCheckingTaskType {
  CITY = 'city',
  COUNTY = 'county'
}

// 案卷类型枚举
export enum CrossCheckingDocType {
  PENALTY = 'penalty',    // 行政处罚
  PERMIT = 'permit'       // 行政许可
}

// 交叉评查任务接口
export interface CrossCheckingTask {
  id: number;
  sequence: number;
  taskName: string;
  startDate: string;
  taskType: CrossCheckingTaskType;
  docType: CrossCheckingDocType;  // 案卷类型
  evaluationRegion: string;
  progress: number;
  status: CrossCheckingTaskStatus;
  score: number;
  operation: string;
  documentIds: number[];
}

// 用户任务文档接口类型定义
export interface UserTaskDocument {
  document_id: number;
  document_name: string;
  document_type_id: number;
  document_type_name: string;
}

// 用户任务信息接口
export interface UserTaskInfo {
  task_id: number;
  task_status: string;
  documents: UserTaskDocument[];
}

// 用户任务API响应格式
export interface UserTaskApiResponse {
  data: UserTaskInfo[];
  pagination: {
    page: number;
    page_size: number;
    total: number;
    total_pages: number;
  };
}

// API响应格式
export interface ApiResponse<T> {
  success: boolean;
  data?: T;
  error?: string;
  message?: string;
  status?: number;
}

// 任务列表查询参数
export interface TaskListParams {
  page?: number;
  pageSize?: number;
  taskType?: string;
  docType?: string;
  status?: string;
  keyword?: string;
  dateFrom?: string;
  dateTo?: string;
}

// 任务列表响应数据
export interface TaskListResponse {
  tasks: CrossCheckingTask[];
  totalCount: number;
  currentPage: number;
  pageSize: number;
  totalPages: number;
}

/**
 * 模拟数据 - 临时使用
 */
const mockTasks: CrossCheckingTask[] = [
  {
    id: 1,
    sequence: 1,
    taskName: '2024年度交叉评查',
    startDate: '2024-12-23',
    taskType: CrossCheckingTaskType.CITY,
    docType: CrossCheckingDocType.PENALTY,
    evaluationRegion: '梅州市、揭阳市、潮州市、云浮市',
    progress: 0,
    status: CrossCheckingTaskStatus.PENDING,
    score: 0,
    operation: '去评查',
    documentIds: [1, 2, 3, 4, 5]
  },
  {
    id: 2,
    sequence: 2,
    taskName: '2024年第4季度交叉评查',
    startDate: '2024-12-05',
    taskType: CrossCheckingTaskType.COUNTY,
    docType: CrossCheckingDocType.PERMIT,
    evaluationRegion: '梅江区、梅县区、平远县、蕉岭县、大埔县、丰顺县、五华县',
    progress: 72,
    status: CrossCheckingTaskStatus.IN_PROGRESS,
    score: 0,
    operation: '进行中',
    documentIds: [1, 2, 3, 4, 5]
  },
  {
    id: 3,
    sequence: 3,
    taskName: '2024年第3季度交叉评查',
    startDate: '2024-9-23',
    taskType: CrossCheckingTaskType.COUNTY,
    docType: CrossCheckingDocType.PERMIT,
    evaluationRegion: '梅江区、梅县区、平远县、蕉岭县、大埔县、丰顺县、五华县',
    progress: 100,
    status: CrossCheckingTaskStatus.COMPLETED,
    score: 95,
    operation: '查看结果',
    documentIds: [1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369, 1370,1371,1372,1373,1374]
  },
  {
    id: 4,
    sequence: 4,
    taskName: '2024年中交叉评查',
    startDate: '2024-6-23',
    taskType: CrossCheckingTaskType.CITY,
    docType: CrossCheckingDocType.PENALTY,
    evaluationRegion: '梅州市、揭阳市、潮州市、云浮市',
    progress: 100,
    status: CrossCheckingTaskStatus.COMPLETED,
    score: 85,
    operation: '查看结果',
    documentIds: [1, 2, 3, 4, 5]
  },
  {
    id: 5,
    sequence: 5,
    taskName: '2024年第2季度交叉评查',
    startDate: '2024-3-23',
    taskType: CrossCheckingTaskType.COUNTY,
    docType: CrossCheckingDocType.PENALTY,
    evaluationRegion: '梅江区、梅县区、平远县、蕉岭县、大埔县、丰顺县、五华县',
    progress: 100,
    status: CrossCheckingTaskStatus.COMPLETED,
    score: 92,
    operation: '查看结果',
    documentIds: [1, 2, 3, 4, 5]
  }
];

/**
 * 获取交叉评查任务列表
 * @param params 查询参数
 * @returns 任务列表响应
 */
export async function getCrossCheckingTasks(params: TaskListParams = {}): Promise<ApiResponse<TaskListResponse>> {
  try {
    console.log('开始调用getCrossCheckingTasks，参数:', params);
    
    // 调用用户任务API，获取当前用户参与的任务
    const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
    
    console.log('getUserTaskDocuments响应:', userTasksResponse);
    
    if (!userTasksResponse.success || !userTasksResponse.data) {
      console.error('获取用户任务失败:', userTasksResponse.error);
      return {
        success: false,
        error: userTasksResponse.error || '获取用户任务失败'
      };
    }

    // 将用户任务数据转换为CrossCheckingTask格式
    const userTasks = userTasksResponse.data;
    const convertedTasks: CrossCheckingTask[] = userTasks.map((userTask: UserTaskInfo, index: number) => {
      // 从用户任务中提取任务信息，如果没有对应信息则使用默认值
      const task: CrossCheckingTask = {
        id: userTask.task_id,
        sequence: index + 1,
        taskName: `任务 ${userTask.task_id}`, // 用户任务API中没有任务名称，使用默认值
        startDate: new Date().toISOString().split('T')[0], // 使用当前日期作为默认值
        taskType: CrossCheckingTaskType.CITY, // 默认任务类型
        docType: CrossCheckingDocType.PENALTY, // 默认案卷类型
        evaluationRegion: '待定', // 默认评查地区
        progress: userTask.task_status === 'completed' ? 100 : 
                 userTask.task_status === 'in_progress' ? 50 : 0,
        status: userTask.task_status === 'completed' ? CrossCheckingTaskStatus.COMPLETED :
                userTask.task_status === 'in_progress' ? CrossCheckingTaskStatus.IN_PROGRESS :
                CrossCheckingTaskStatus.PENDING,
        score: userTask.task_status === 'completed' ? 85 : 0, // 默认分数
        operation: userTask.task_status === 'completed' ? '查看结果' :
                  userTask.task_status === 'in_progress' ? '进行中' : '去评查',
        documentIds: userTask.documents.map((doc: UserTaskDocument) => doc.document_id)
      };
      return task;
    });

    const {
      page = 1,
      pageSize = 10,
      taskType,
      docType,
      status,
      keyword,
      dateFrom,
      dateTo
    } = params;

    // 筛选数据
    let filteredTasks = [...convertedTasks];

    // 按任务类型筛选
    if (taskType && taskType !== 'all') {
      filteredTasks = filteredTasks.filter(task => task.taskType === taskType);
    }

    // 按案卷类型筛选
    if (docType && docType !== 'all') {
      filteredTasks = filteredTasks.filter(task => task.docType === docType);
    }

    // 按状态筛选
    if (status && status !== 'all') {
      filteredTasks = filteredTasks.filter(task => task.status === status);
    }

    // 按关键词搜索
    if (keyword) {
      const lowerKeyword = keyword.toLowerCase();
      filteredTasks = filteredTasks.filter(task => 
        task.taskName.toLowerCase().includes(lowerKeyword) ||
        task.evaluationRegion.toLowerCase().includes(lowerKeyword)
      );
    }

    // 按日期范围筛选
    if (dateFrom || dateTo) {
      filteredTasks = filteredTasks.filter(task => {
        const taskDate = new Date(task.startDate);
        if (dateFrom && new Date(dateFrom) > taskDate) return false;
        if (dateTo && new Date(dateTo) < taskDate) return false;
        return true;
      });
    }

    // 分页处理
    const totalCount = filteredTasks.length;
    const totalPages = Math.ceil(totalCount / pageSize);
    const startIndex = (page - 1) * pageSize;
    const endIndex = startIndex + pageSize;
    const paginatedTasks = filteredTasks.slice(startIndex, endIndex);

    return {
      success: true,
      data: {
        tasks: paginatedTasks,
        totalCount,
        currentPage: page,
        pageSize,
        totalPages
      }
    };
  } catch (error) {
    console.error('获取交叉评查任务列表失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取任务列表失败'
    };
  }
}

/**
 * 创建新的交叉评查任务
 * @param taskData 任务数据
 * @returns 创建结果
 */
export async function createCrossCheckingTask(taskData: Omit<CrossCheckingTask, 'id' | 'sequence' | 'progress' | 'score'>): Promise<ApiResponse<CrossCheckingTask>> {
  try {
    // 模拟API延迟
    await new Promise(resolve => setTimeout(resolve, 800));

    const newTask: CrossCheckingTask = {
      ...taskData,
      id: Math.max(...mockTasks.map(t => t.id)) + 1,
      sequence: mockTasks.length + 1,
      progress: 0,
      score: 0
    };

    // 添加到模拟数据
    mockTasks.unshift(newTask);

    return {
      success: true,
      data: newTask,
      message: '创建任务成功'
    };
  } catch (error) {
    console.error('创建交叉评查任务失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '创建任务失败'
    };
  }
}

/**
 * 删除交叉评查任务
 * @param taskId 任务ID
 * @returns 删除结果
 */
export async function deleteCrossCheckingTask(taskId: number): Promise<ApiResponse<boolean>> {
  try {
    // 模拟API延迟
    await new Promise(resolve => setTimeout(resolve, 500));

    const taskIndex = mockTasks.findIndex(task => task.id === taskId);
    if (taskIndex === -1) {
      return {
        success: false,
        error: '任务不存在'
      };
    }

    // 从模拟数据中删除
    mockTasks.splice(taskIndex, 1);

    return {
      success: true,
      data: true,
      message: '删除任务成功'
    };
  } catch (error) {
    console.error('删除交叉评查任务失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '删除任务失败'
    };
  }
}

/**
 * 获取任务详情及相关文档
 * @param taskId 任务ID
 * @param documentIds 指定的文档ID数组，用于筛选任务包含的文档
 * @param page 页码，默认为1
 * @param pageSize 每页大小，默认为10
 * @returns 任务详情和文档列表
 */
export async function getCrossCheckingTaskDetail(
  taskId: number, 
  documentIds: number[], 
  page: number = 1, 
  pageSize: number = 10
): Promise<ApiResponse<{
  task: CrossCheckingTask;
  files: import('../evaluation_points/rules-files').ReviewFileUI[];
  total: number;
}>> {
  try {
    // 从用户任务API中获取任务信息
    const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
    
    if (!userTasksResponse.success || !userTasksResponse.data) {
      console.error('获取用户任务失败:', userTasksResponse.error);
      return {
        success: false,
        error: userTasksResponse.error || '获取用户任务失败'
      };
    }

    // 查找指定的任务
    const userTask = userTasksResponse.data.find(t => t.task_id === taskId);
    if (!userTask) {
      return {
        success: false,
        error: '任务不存在'
      };
    }

    // 将用户任务转换为CrossCheckingTask格式
    const task: CrossCheckingTask = {
      id: userTask.task_id,
      sequence: 1, // 暂时使用默认值
      taskName: `任务 ${userTask.task_id}`, // 用户任务API中没有任务名称，使用默认值
      startDate: new Date().toISOString().split('T')[0], // 使用当前日期作为默认值
      taskType: CrossCheckingTaskType.CITY, // 默认任务类型
      docType: CrossCheckingDocType.PENALTY, // 默认案卷类型
      evaluationRegion: '待定', // 默认评查地区
      progress: userTask.task_status === 'completed' ? 100 : 
               userTask.task_status === 'in_progress' ? 50 : 0,
      status: userTask.task_status === 'completed' ? CrossCheckingTaskStatus.COMPLETED :
              userTask.task_status === 'in_progress' ? CrossCheckingTaskStatus.IN_PROGRESS :
              CrossCheckingTaskStatus.PENDING,
      score: userTask.task_status === 'completed' ? 85 : 0, // 默认分数
      operation: userTask.task_status === 'completed' ? '查看结果' :
                userTask.task_status === 'in_progress' ? '进行中' : '去评查',
      documentIds: userTask.documents.map(doc => doc.document_id)
    };

    let files: import('../evaluation_points/rules-files').ReviewFileUI[] = [];
    let total = 0;

    // 如果提供了documentIds，则调用getReviewFiles获取相关文档
    if (documentIds && documentIds.length > 0) {
      const { getReviewFiles } = await import('../evaluation_points/rules-files');
      
      const reviewFilesResponse = await getReviewFiles({
        page: page,
        pageSize: pageSize,
        sortOrder: 'upload_time_desc'
      }, documentIds);
      
      if (reviewFilesResponse.error) {
        return {
          success: false,
          error: reviewFilesResponse.error
        };
      }
      
      files = reviewFilesResponse.data?.files || [];
      total = reviewFilesResponse.data?.total || 0;
    }

    console.log('files', files);

    return {
      success: true,
      data: {
        task,
        files,
        total
      }
    };
  } catch (error) {
    console.error('获取任务详情失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取任务详情失败'
    };
  }
}

/**
 * 获取统计数据
 * @returns 统计数据
 */
export async function getCrossCheckingStats(): Promise<ApiResponse<{
  totalTasks: number;
  pendingTasks: number;
  inProgressTasks: number;
  completedTasks: number;
}>> {
  try {
    console.log('开始调用getCrossCheckingStats');
    
    // 获取用户任务数据来计算统计
    const userTasksResponse = await getUserTaskDocuments(1); // 暂时使用固定用户ID 1
    
    if (!userTasksResponse.success || !userTasksResponse.data) {
      console.error('获取用户任务失败:', userTasksResponse.error);
      return {
        success: false,
        error: userTasksResponse.error || '获取用户任务失败'
      };
    }

    const userTasks = userTasksResponse.data;
    const totalTasks = userTasks.length;
    const pendingTasks = userTasks.filter(t => t.task_status === 'pending').length;
    const inProgressTasks = userTasks.filter(t => t.task_status === 'in_progress').length;
    const completedTasks = userTasks.filter(t => t.task_status === 'completed').length;

    return {
      success: true,
      data: {
        totalTasks,
        pendingTasks,
        inProgressTasks,
        completedTasks
      }
    };
  } catch (error) {
    console.error('获取统计数据失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取统计数据失败'
    };
  }
}

// ==================== 新增：用户任务文档相关接口 ====================

// 导入API客户端
import { post } from '../axios-client';

/**
 * 获取用户参与的所有任务及文档
 * @param userId 用户ID
 * @returns 用户任务及文档列表
 */
export async function getUserTaskDocuments(userId: number): Promise<ApiResponse<UserTaskInfo[]>> {
  try {
    console.log('开始调用用户任务API，用户ID:', userId);
    
    // 导入API配置以显示当前使用的baseUrl
    const { API_BASE_URL } = await import('../../config/api-config');
    console.log('当前API基础URL:', API_BASE_URL);
    
    // 调用真实的API接口
    console.log('调用API路径:', '/admin/cross_review/tasks/user_documents');
    console.log('完整API URL:', `${API_BASE_URL}/admin/cross_review/tasks/user_documents`);
    console.log('请求参数:', { user_id: userId });
    
    const response = await post<UserTaskApiResponse>(
      '/admin/cross_review/tasks/user_documents',
      { user_id: userId }
    );

    console.log('API响应:', response);
    
    // 如果API调用失败，尝试使用模拟数据作为回退
    if (response.error) {
      console.warn('API调用失败，使用模拟数据作为回退');
      // 返回模拟数据
      const mockUserTasks: UserTaskInfo[] = [
        {
          task_id: 1,
          task_status: 'completed',
          documents: [
            { document_id: 1, document_name: '测试文档1', document_type_id: 1, document_type_name: '行政处罚' },
            { document_id: 2, document_name: '测试文档2', document_type_id: 1, document_type_name: '行政处罚' }
          ]
        },
        {
          task_id: 2,
          task_status: 'in_progress',
          documents: [
            { document_id: 3, document_name: '测试文档3', document_type_id: 2, document_type_name: '行政许可' }
          ]
        }
      ];
      
      return {
        success: true,
        data: mockUserTasks
      };
    }

    if (response.error) {
      console.error('获取用户任务及文档失败:', response.error);
      return {
        success: false,
        error: response.error
      };
    }

    // 确保返回的数据是数组格式
    let userTasks: UserTaskInfo[] = [];
    
    if (response.data) {
      // 检查响应数据的结构
      console.log('响应数据结构:', response.data);
      
      // 根据实际API响应结构，数据在response.data.data中
      if (response.data.data && Array.isArray(response.data.data)) {
        userTasks = response.data.data;
      } else if (Array.isArray(response.data)) {
        // 备用方案：如果数据直接在response.data中
        userTasks = response.data;
      } else {
        console.warn('响应数据格式不正确:', response.data);
        userTasks = [];
      }
    }
    
    console.log('解析后的用户任务数据:', userTasks);
    
    return {
      success: true,
      data: userTasks
    };
  } catch (error) {
    console.error('获取用户任务及文档失败:', error);
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取用户任务及文档失败'
    };
  }
}