import { postgrestPut, postgrestPost } from '../postgrest-client';
import { formatDate } from '../../utils';

// 文档数据库表接口
export interface Document {
  id: number;
  user_id: number | null;
  type_id: number;
  name: string;
  document_number: string;
  path: string;
  storage_type: string;
  file_size: number;
  upload_time: string;
  is_test_document: boolean;
  evaluation_level: string;
  status: string;
  ocr_result: Record<string, unknown>;
  extracted_results: Record<string, unknown> | null;
  sumary: string | null;
  remark: string;
  created_at: string;
  updated_at: string;
  evaluations_status: number | null;
  audit_status: number | null;
}

// 文档类型接口
export interface DocumentType {
  id: number;
  name: string;
  description: string | null;
  status: number;
  created_at: string;
  updated_at: string;
}

// 评查文件UI接口
export interface ReviewFileUI {
  id: string;
  status: string;
  path: string;
  fileName: string;
  fileCode: string;
  fileType: string;
  fileTypeId: number;
  fileSize: number;
  uploadTime: string;
  reviewStatus: string;
  reviewStatusCode: number;
  issueCount: number;
  score?: number;
  auditStatus: number | null;
  issues: Array<{
    severity: 'info' | 'warning' | 'error' | 'critical';
    message: string;
  }>;
  createdBy: string;
  passCount: number;
  warningCount: number;
  failCount: number;
  manualCount: number;
}

// 数据库函数返回的评查文件结构
interface ReviewFileFromSQL {
  id: number;
  status: string;
  path: string;
  file_name: 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 | null;
  created_by_user_id: number | null;
  issue_count: number;
  total_score: number;
  pass_count: number;
  warning_count: number;
  fail_count: number;
  manual_count: number;
  issues: Array<{
    severity: 'info' | 'warning' | 'error' | 'critical';
    message: string;
  }> | null;
}

// 文件列表搜索参数
export interface DocumentSearchParams {
  fileType?: string; // 文件类型ID
  reviewStatus?: string; // 评查状态
  // dateRange?: string; // 日期范围
  dateFrom?: string; // 开始日期
  dateTo?: string; // 结束日期
  keyword?: string; // 搜索关键字
  sortOrder?: string; // 排序方式
  page?: number; // 当前页码
  pageSize?: number; // 每页条数
}


/**
 * 将评查状态代码映射到UI状态
 * @param status 评查状态代码
 * @returns UI状态
 */
export function mapReviewStatusToUI(status: number | null): string {
  switch(status) {
    case 1: return 'pass';
    case -2: return 'warning';
    case -1: return 'fail';
    case 0: return 'pending';
    default: return 'pending';
  }
}

/**
 * 将UI状态映射到评查状态代码
 * @param status UI状态
 * @returns 评查状态代码
 */
export function mapUIToReviewStatus(status: string): number {
  switch(status) {
    case 'pass': return 1;
    case 'warning': return -2;
    case 'fail': return -1;
    case 'pending': return 0;
    default: return 0;
  }
}

/**
 * 获取文件扩展名
 * @param fileName 文件名
 * @returns 文件扩展名
 */
export function getFileExtension(fileName: string): string {
  return fileName.split('.').pop()?.toLowerCase() || '';
}

/**
 * 获取评查文件列表
 * @param searchParams 搜索参数
 * @param documentIds 文档ID数组（可选）
 * @param userId 用户ID
 * @returns 评查文件列表和总数
 */
export async function getReviewFiles(searchParams: DocumentSearchParams = {}, documentIds: number[] | null = null, userId?: string): Promise<{
  data?: { files: ReviewFileUI[], total: number };
  error?: string;
  status?: number;
}> {
  try {
    // 确保userId必须存在，如果不存在则抛出错误
    if (!userId) {
      return { error: '用户身份验证失败，无法获取评查文件列表', status: 401 };
    }

    const {
      page = 1,
      pageSize = 10,
      keyword,
      fileType,     // sessionStorage.getItem('reviewType')
      reviewStatus,
      dateFrom,
      dateTo,
      sortOrder = 'upload_time_desc'
    } = searchParams;

    let p_typeid: number[] | null = null;
    if (fileType) {
      if (fileType === 'record') {
        p_typeid = [2, 3];
      } else if (fileType === 'contract') {
        p_typeid = [1];
      } else {
        const typeId = parseInt(fileType, 10);
        if (!isNaN(typeId)) {
          p_typeid = [typeId];
        }
      }
    }

    const rpcParams = {
      p_keyword: keyword || null,
      p_typeid: p_typeid,
      p_evaluations_status: reviewStatus ? mapUIToReviewStatus(reviewStatus) : null,
      p_date_from: dateFrom || null,
      p_date_to: dateTo || null,
      p_document_ids: documentIds || null,
      p_user_id: parseInt(userId, 10), // 强制要求传递用户ID
    };
    
    const listParams = {
      ...rpcParams,
      p_page: page,
      p_page_size: pageSize,
      p_sort_order: sortOrder
    };

    // 并行执行获取数据和获取总数的请求
    const [filesResponse, countResponse] = await Promise.all([
      postgrestPost<ReviewFileFromSQL[]>('rpc/get_review_files_with_details', listParams),
      postgrestPost<number>('rpc/count_review_files', rpcParams)
    ]);
    
    // 处理获取文档列表的错误
    if (filesResponse.error || !filesResponse.data) {
      return { error: filesResponse.error || '获取文档数据失败', status: filesResponse.status || 500 };
    }
    
    // 处理获取总数的错误
    if (countResponse.error || typeof countResponse.data !== 'number') {
        console.error('获取文档总数失败:', countResponse.error);
    }
    
    const totalCount = typeof countResponse.data === 'number' ? countResponse.data : 0;
    
    // 将SQL返回的数据转换为UI格式
    const reviewFiles: ReviewFileUI[] = filesResponse.data.map((file: ReviewFileFromSQL) => ({
      id: file.id.toString(),
      status: file.status,
      path: file.path,
      fileName: file.file_name,
      fileCode: file.file_code,
      fileType: file.file_type_name,
      fileTypeId: file.file_type_id,
      fileSize: file.file_size,
      uploadTime: formatDate(file.created_at),
      reviewStatus: mapReviewStatusToUI(file.evaluations_status),
      reviewStatusCode: file.evaluations_status,
      issueCount: file.issue_count,
      score: file.total_score,
      auditStatus: file.audit_status,
      issues: file.issues || [],
      createdBy: file.created_by_user_id?.toString() || '系统',
      passCount: file.pass_count,
      warningCount: file.warning_count,
      failCount: file.fail_count,
      manualCount: file.manual_count,
    }));
    
    return {
      data: {
        files: reviewFiles,
        total: totalCount
      }
    };
  } catch (error) {
    console.error('获取评查文件列表失败:', error);
    return {
      error: error instanceof Error ? error.message : '获取评查文件列表失败',
      status: 500
    };
  }
}

/**
 * 更新文件的评查状态
 * @param id 文件ID
 * @param status 评查状态
 * @returns 更新后的文件信息
 */
// export async function updateReviewStatus(id: string, status: string): Promise<{
//   data?: ReviewFileUI;
//   error?: string;
//   status?: number;
// }> {
//   try {
//     if (!id) {
//       return { error: '文件ID不能为空', status: 400 };
//     }
    
//     const statusValue = mapUIToReviewStatus(status);
    
//     const response = await postgrestPut<Document, Partial<Document>>(
//       'documents',
//       { evaluations_status: statusValue },
//       { id: parseInt(id) }
//     );
    
//     if (response.error) {
//       return { error: response.error, status: response.status };
//     }
    
//     const extractedData = extractApiData<Document>(response.data);
    
//     if (!extractedData) {
//       return { error: '更新评查状态失败', status: 500 };
//     }
    
//     // 获取文档类型，用于查找文档类型名称
//     const documentTypesResponse = await getDocumentTypes({pageSize: 500});
//     const documentTypes = documentTypesResponse.data?.types || [];
    
//     // 查找文档类型名称
//     const docType = documentTypes.find((type: DocumentTypeUI) => type.id === extractedData.type_id);
//     const typeName = docType ? docType.name : '未知类型';
    
//     return { data: convertToReviewFileUI(extractedData, typeName) };
//   } catch (error) {
//     console.error('更新评查状态失败:', error);
//     return {
//       error: error instanceof Error ? error.message : '更新评查状态失败',
//       status: 500
//     }
//   }
// }

/**
 * 更新文件的审核状态
 * @param id 文件ID
 * @param auditStatus 审核状态
 * @param userId 用户ID
 * @returns 更新结果
 */
export async function updateDocumentAuditStatus(id: string, auditStatus: number, userId: string): Promise<{
  success?: boolean;
  error?: string;
  status?: number;
}> {
  try {
    if (!id) {
      return { error: '文件ID不能为空', status: 400 };
    }
    
    if (!userId) {
      return { error: '用户身份验证失败', status: 401 };
    }
    
    const response = await postgrestPut<Document, Partial<Document>>(
      'documents',
      { audit_status: auditStatus },
      { 
        id: parseInt(id),
        user_id: parseInt(userId) // 确保只能更新自己的文档
      }
    );
    
    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
    };
  }
}