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

// 交叉评查任务状态枚举
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: string;  // 改为直接使用返回的 doc_type 字符串
  evaluationRegion: string;
  progress: number;
  status: string;  // 改为直接使用返回的 task_status 字符串
  score: number;
  operation: string;
  documents: UserTaskDocument[];  // 改为 documents 数组，包含完整的文档信息
  totalDocuments?: number;  // 新增：任务包含的文档总数
}

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

// 新的用户任务信息接口（根据新的API格式）
export interface UserTaskInfo {
  task_id: number;
  task_name?: string;
  task_status: string;
  doc_type?: string;
  task_created_at?: string;
  progress?: number;
  total_documents?: number;  // 新增：任务包含的文档总数
}

// 用户任务API响应格式（新格式）
export interface UserTaskApiResponse {
  total: number;
  page: number;
  page_size: number;
  items: UserTaskInfo[];
}

// 任务文档接口类型定义（新增）
export interface TaskDocument {
  document_id: number;
  file_name: string;
  status: string;
  path: string;
  file_code: string;
  file_type_name: string;
  file_type_id: number;
  file_size: number;
  upload_time: string;
  created_at: string;
  evaluations_status: number;
  audit_status: number;
  created_by_user_id: number;
  issues: Array<{
    severity: string;
    message: string;
  }>;
  final_score: number;
  score_summary: string ;
  score_percent?: number | null;
  pass_count: number;
  warning_count: number;
  fail_count: number;
  manual_count: number;
}

// 任务文档API响应格式（新增）
export interface TaskDocumentApiResponse {
  total: number;
  page: number;
  page_size: number;
  items: TaskDocument[];
}

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



/**
 * 获取交叉评查任务列表
 * @param params 查询参数
 * @param userInfo 用户信息
 * @param jwtToken JWT token
 * @returns 任务列表响应
 */
export async function getCrossCheckingTasks(params: TaskListParams = {}, userInfo?: { user_id?: number; [key: string]: unknown }, jwtToken?: string): Promise<ApiResponse<TaskListResponse>> {
  try {
    console.log('开始调用getCrossCheckingTasks，参数:', params);
    
    // 调用用户任务API，获取当前用户参与的任务
    const userTasksResponse = await getUserTaskDocuments(params.page || 1, params.pageSize || 10, jwtToken);
    
    // console.log('getUserTaskDocuments响应:', JSON.stringify(userTasksResponse,null,2));
    
    if (!userTasksResponse.success || !userTasksResponse.data) {
      console.error('获取用户任务失败:', userTasksResponse.error);
      return {
        success: false,
        error: userTasksResponse.error || '获取用户任务失败'
      };
    }

    // 将用户任务数据转换为CrossCheckingTask格式
    const userTasks = userTasksResponse.data.items;
    const convertedTasks: CrossCheckingTask[] = userTasks.map((userTask: UserTaskInfo, index: number) => {
      // 从用户任务中提取任务信息，使用API返回的实际数据
      const task: CrossCheckingTask = {
        id: userTask.task_id,
        sequence: index + 1,
        taskName: userTask.task_name || `任务 ${userTask.task_id}`, // 使用API返回的任务名称
        startDate: userTask.task_created_at ? new Date(userTask.task_created_at).toISOString().split('T')[0] : new Date().toISOString().split('T')[0],
        taskType: CrossCheckingTaskType.CITY, // 保持默认任务类型
        docType: userTask.doc_type || '未知类型', // 使用API返回的文档类型
        evaluationRegion: '待定', // 保持默认评查地区
        progress: userTask.progress || 0, // 使用API返回的进度
        status: userTask.task_status || 'pending', // 使用API返回的任务状态
        score: userTask.task_status === 'completed' ? 85 : 0, // 默认分数
        operation: userTask.task_status === 'completed' ? '查看结果' :
                  userTask.task_status === 'in_progress' ? '进行中' : '去评查',
        documents: [], // 暂时为空数组，因为新API格式中任务列表不包含具体文档信息
        totalDocuments: userTask.total_documents || 0 // 使用API返回的文档总数
      };
      return task;
    });

    const {
      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;
      });
    }

    return {
      success: true,
      data: {
        tasks: filteredTasks,
        totalCount: userTasksResponse.data.total,
        currentPage: userTasksResponse.data.page,
        pageSize: userTasksResponse.data.page_size,
        totalPages: Math.ceil(userTasksResponse.data.total / userTasksResponse.data.page_size)
      }
    };
  } 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));

    // 这里应该调用实际的API来删除任务
    // 目前暂时返回成功，因为没有实际的删除API
    console.log(`尝试删除任务ID: ${taskId}`);

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

/**
 * 获取任务详情及相关文档
 * @param taskId 任务ID
 * @param page 页码，默认为1
 * @param pageSize 每页大小，默认为10
 * @param jwtToken JWT token
 * @returns 任务详情和文档列表
 */
export async function getCrossCheckingTaskDetail(
  taskId: number, 
  page: number = 1, 
  pageSize: number = 10,
  jwtToken?: string
): Promise<ApiResponse<{
  task: CrossCheckingTask | null;
  files: TaskDocument[];
  total: number;
  currentPage: number;
  pageSize: number;
}>> {
  try {
    console.log('开始调用getCrossCheckingTaskDetail，参数:', { taskId, page, pageSize });
    
    // 获取任务的文档列表
    const taskDocumentsResponse = await getTaskDocuments(taskId, page, pageSize, jwtToken);
    
    if (!taskDocumentsResponse.success || !taskDocumentsResponse.data) {
      console.error('获取任务文档失败:', taskDocumentsResponse.error);
      return {
        success: false,
        error: taskDocumentsResponse.error || '获取任务文档失败'
      };
    }

    const documentsData = taskDocumentsResponse.data;

    const result = {
      success: true,
      data: {
        task: null, // 暂时不返回任务详情，因为新接口主要关注文档列表
        files: documentsData.items,
        total: documentsData.total,
        currentPage: documentsData.page,
        pageSize: documentsData.page_size
      }
    };

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

/**
 * 获取统计数据
 * @param userInfo 用户信息
 * @param jwtToken JWT token
 * @returns 统计数据
 */
export async function getCrossCheckingStats(userInfo?: { user_id?: number; [key: string]: unknown }, jwtToken?: string): Promise<ApiResponse<{
  totalTasks: number;
  pendingTasks: number;
  inProgressTasks: number;
  completedTasks: number;
}>> {
  try {
    console.log('开始调用getCrossCheckingStats');
    
    // 获取用户任务数据来计算统计（默认获取第一页数据进行统计）
    const userTasksResponse = await getUserTaskDocuments(1, 100, jwtToken); // 获取前100个任务用于统计
    
    if (!userTasksResponse.success || !userTasksResponse.data) {
      console.error('获取用户任务失败:', userTasksResponse.error);
      return {
        success: false,
        error: userTasksResponse.error || '获取用户任务失败'
      };
    }

    const userTasks = userTasksResponse.data.items;
    const totalTasks = userTasksResponse.data.total;
    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格式）
 * @param page 页码
 * @param pageSize 每页大小
 * @param jwtToken JWT token
 * @returns 用户任务列表
 */
export async function getUserTaskDocuments(page: number = 1, pageSize: number = 10, jwtToken?: string): Promise<ApiResponse<UserTaskApiResponse>> {
  try {
    // 拼接绝对路径，去除多余斜杠
    const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
    const url = `${base}/admin/cross_review/tasks/user_tasks`;
    
    const response = await fetch(url, {
      method: 'POST',
      headers: { 
        'Content-Type': 'application/json', 
        'Authorization': `Bearer ${jwtToken || ''}` 
      },
      body: JSON.stringify({ 
        page: page,
        page_size: pageSize 
      })
    });
    
    if (!response.ok) {
      return {
        success: false,
        error: `HTTP ${response.status}: ${response.statusText}`
      };
    }
    
    const result = await response.json();
    
    return {
      success: true,
      data: result
    };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取用户任务列表失败'
    };
  }
}

/**
 * 获取指定任务的文档列表（新增接口）
 * @param taskId 任务ID
 * @param page 页码
 * @param pageSize 每页大小
 * @param jwtToken JWT token
 * @returns 任务文档列表
 */
export async function getTaskDocuments(taskId: number, page: number = 1, pageSize: number = 10, jwtToken?: string): Promise<ApiResponse<TaskDocumentApiResponse>> {
  try {
    // 拼接绝对路径，去除多余斜杠
    const base = API_BASE_URL.endsWith('/') ? API_BASE_URL.slice(0, -1) : API_BASE_URL;
    const url = `${base}/admin/cross_review/tasks/${taskId}/documents`;
    // console.log('最终请求URL:', url);
    
    const response = await fetch(url, {
      method: 'POST',
      headers: { 
        'Content-Type': 'application/json', 
        'Authorization': `Bearer ${jwtToken || ''}` 
      },
      body: JSON.stringify({ 
        page: page,
        page_size: pageSize 
      })
    });
    
    if (!response.ok) {
      return {
        success: false,
        error: `HTTP ${response.status}: ${response.statusText}`
      };
    }
    
    const result = await response.json();
    
    return {
      success: true,
      data: result
    };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : '获取任务文档列表失败'
    };
  }
}


/**
 * 更新文件的审核状态
 * @param id 文件ID
 * @param auditStatus 审核状态
 * @returns 更新结果
 */
export async function updateDocumentAuditStatus(id: string, auditStatus: number): Promise<{
  success?: boolean;
  error?: string;
  status?: number;
}> {
  try {
    if (!id) {
      return { error: '文件ID不能为空', status: 400 };
    }
    
    const response = await postgrestPut<TaskDocument, Partial<TaskDocument>>(
      'documents',
      { audit_status: auditStatus },
      { 
        id: parseInt(id)
      }
    );
    
    if (response.error) {
      return { error: response.error, status: response.status };
    }
    
    return { success: true };
  } catch (error) {
    console.error('更新文件审核状态失败:', error);
    return {
      error: error instanceof Error ? error.message : '更新文件审核状态失败',
      status: 500
    };
  }
}