// 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;
}

// 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: '去评查'
  },
  {
    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: '进行中'
  },
  {
    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: '查看结果'
  },
  {
    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: '查看结果'
  },
  {
    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: '查看结果'
  }
];

/**
 * 获取交叉评查任务列表
 * @param params 查询参数
 * @returns 任务列表响应
 */
export async function getCrossCheckingTasks(params: TaskListParams = {}): Promise<ApiResponse<TaskListResponse>> {
  try {
    // 模拟API延迟
    await new Promise(resolve => setTimeout(resolve, 500));
    
    const {
      page = 1,
      pageSize = 10,
      taskType,
      docType,
      status,
      keyword,
      dateFrom,
      dateTo
    } = params;

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

    // 按任务类型筛选
    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
 * @returns 任务详情
 */
export async function getCrossCheckingTaskDetail(taskId: number): Promise<ApiResponse<CrossCheckingTask>> {
  try {
    // 模拟API延迟
    await new Promise(resolve => setTimeout(resolve, 300));

    const task = mockTasks.find(t => t.id === taskId);
    if (!task) {
      return {
        success: false,
        error: '任务不存在'
      };
    }

    return {
      success: true,
      data: task
    };
  } 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 {
    const totalTasks = mockTasks.length;
    const pendingTasks = mockTasks.filter(t => t.status === CrossCheckingTaskStatus.PENDING).length;
    const inProgressTasks = mockTasks.filter(t => t.status === CrossCheckingTaskStatus.IN_PROGRESS).length;
    const completedTasks = mockTasks.filter(t => t.status === CrossCheckingTaskStatus.COMPLETED).length;

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