/*
 * @Description: 文献库 API - 按 DOI / arXiv / PMID / ISBN 导入文献（仅落库）
 * Copyright (c) 2025 by 北京连心医疗科技有限公司, All Rights Reserved.
 */
import { service as http } from "@/utils/request";

/** 通用：导入结果项（DOI/arXiv/PMID/ISBN） */
export interface ReferenceImportItem {
  workId?: number;
  doi?: string;
  title?: string;
  publicationYear?: number;
  fileLibraryItemId?: number;
  createdNewWork?: boolean;
  createdFileLink?: boolean;
  source?: string;
  authorsText?: string;
  itemType?: string;
  venueName?: string;
  journalAbbr?: string;
  issn?: string;
  volume?: string;
  issue?: string;
  pages?: string;
  language?: string;
  landingUrl?: string;
  pdfUrl?: string;
}

/** 导入响应 */
export interface ReferenceImportResponse {
  items?: ReferenceImportItem[];
}

/** 通用：BibTeX 导入条目响应 */
export interface BibtexImportItemResponse {
  doi?: string;
  workId?: number;
  createdNewWork?: boolean;
  linkedToFile?: boolean;
  addedToUserLibrary?: boolean;
  message?: string;
}

/** BibTeX 导入响应 */
export interface BibtexImportResponse {
  items?: BibtexImportItemResponse[];
  message?: string;
  success?: number;
  failed?: number;
}

/** 导入 BibTeX 文献（JSON 字符串，仅落库）请求 */
export interface ImportReferenceByBibtexRequest {
  bibtex: string;
  linkToFileId?: number;
  linkToId?: number;
  isDraft?: boolean;
  overwriteNote?: boolean;
  addToUserLibrary?: boolean;
}

/** 导入 BibTeX 文献（multipart 统一上传端点，仅落库）请求 */
export interface ImportReferenceByBibtexFileRequest {
  file?: File;
  isDraft?: boolean;
  overwriteNote?: boolean;
  addToUserLibrary?: boolean;
}

/** 导入 RIS 文献（JSON 字符串，仅落库）请求 */
export interface ImportReferenceByRisRequest {
  ris: string;
  // 旧参数/新参数兼容：后端以实际支持为准
  linkToFileId?: number;
  linkToId?: number;
  isDraft?: boolean;
  overwriteNote?: boolean;
  addToUserLibrary?: boolean;
}

/** 导入 RIS 文献（multipart 统一上传端点，仅落库）请求 */
export interface ImportReferenceByRisFileRequest {
  file?: File;
  isDraft?: boolean;
  overwriteNote?: boolean;
  addToUserLibrary?: boolean;
}

/** 用户文献库项（library item） */
export interface UserLibraryItem {
  id?: number;
  userId?: number;
  workId?: number;
  note?: string;
  collectionIds?: number[];
  workTitle?: string;
  workDoi?: string;
  workAuthors?: string;
  venueName?: string;
  journalAbbr?: string;
  publicationYear?: number;
  itemType?: string;
  documentCount?: number;
  createdAt?: string;
  updatedAt?: string;
}

/** 新增/修改用户文献库项请求 */
export interface UpsertUserLibraryItemRequest {
  workId: number;
  note?: string;
  collectionIds?: number[];
}

/** 查询用户文献库项列表请求参数 */
export interface GetUserLibraryItemsQuery {
  page?: number; // 从 0 开始，默认 0
  size?: number; // 默认 10
  keyword?: string; // 模糊匹配标题、作者名、DOI
  itemType?: string; // 文章类别筛选
  yearFrom?: number;
  yearTo?: number;
}

/** 删除用户文献库项响应（204 时可能无 body） */
export interface DeleteUserLibraryItemResponse {
  message?: string;
}

/** 批量删除用户文献库项请求 */
export interface BatchDeleteUserLibraryItemsRequest {
  ids: number[];
}

/** 新增/修改文献集请求 */
export interface UpsertUserLibraryCollectionRequest {
  name: string;
  description?: string;
}

/** 文献集响应 */
export interface UserLibraryCollectionItem {
  id?: number;
  userId?: number;
  name?: string;
  description?: string;
  documentCount?: number;
  createdAt?: string;
  updatedAt?: string;
}

/** 文献集列表查询参数 */
export interface GetUserLibraryCollectionsQuery {
  page?: number; // 页码，从0开始
  size?: number; // 每页数量
  keyword?: string; // 关键词搜索，匹配名称或描述
}

/** 新增文献集子列表项请求 */
export interface UpsertUserLibraryCollectionDocumentRequest {
  workId: number;
}

/** 文献集子列表项响应 */
export interface UserLibraryCollectionDocumentItem {
  id?: number;
  collectionId?: number;
  workId?: number;
  workTitle?: string;
  workDoi?: string;
  workAuthors?: string;
  venueName?: string;
  journalAbbr?: string;
  publicationYear?: number;
  createdAt?: string;
}

/** 文献集子列表查询参数 */
export interface GetUserLibraryCollectionDocumentsQuery {
  page?: number; // 页码，从0开始
  size?: number; // 每页数量
}

/** 删除文献集响应（204 时可能无 body） */
export interface DeleteUserLibraryCollectionResponse {
  message?: string;
}

/** 批量删除文献集请求 */
export interface BatchDeleteUserLibraryCollectionsRequest {
  ids: number[];
}

/** 删除文献集子列表项响应（204 时可能无 body） */
export interface DeleteUserLibraryCollectionDocumentResponse {
  message?: string;
}

/** 批量删除文献集子列表项请求 */
export interface BatchDeleteUserLibraryCollectionDocumentsRequest {
  workIds: number[];
}

// 小工具：拼 query params，过滤 undefined
function qp(obj: any = {}) {
  const params: any = {};
  Object.keys(obj).forEach((k) => {
    const v = obj[k];
    if (v !== undefined && v !== null) params[k] = v;
  });
  return params;
}

/**
 * 按 DOI 导入文献（仅落库）
 * @param doi DOI，支持带/不带 https://doi.org/ 前缀，0-255 字符
 * @returns 导入结果集合
 */
export const importReferenceByDoi = (doi: string) => {
  return http.post<ReferenceImportResponse>("/references/import/by-doi", {
    doi,
  });
};

/**
 * 按 arXiv URL 导入文献（仅落库）
 * @param arxivUrl arXiv URL 或 arXiv ID，0-255 字符，如 https://arxiv.org/abs/2301.00001
 * @returns 导入结果集合
 */
export const importReferenceByArxiv = (arxivUrl: string) => {
  return http.post<ReferenceImportResponse>("/references/import/by-arxiv", {
    arxivUrl,
  });
};

/**
 * 按 PMID 导入文献（仅落库）
 * @param pmid PubMed ID，0-20 字符，如 14907713
 * @returns 导入结果集合
 */
export const importReferenceByPmid = (pmid: string) => {
  return http.post<ReferenceImportResponse>("/references/import/by-pmid", {
    pmid,
  });
};

/**
 * 按 ISBN 导入文献（仅落库）
 * @param isbn ISBN（10 位或 13 位，可带连字符），0-30 字符，如 978-0-13-110362-7
 * @returns 导入结果集合
 */
export const importReferenceByIsbn = (isbn: string) => {
  return http.post<ReferenceImportResponse>("/references/import/by-isbn", {
    isbn,
  });
};

/**
 * POST /api/references/import/bibtex
 * 导入 BibTeX 文献（JSON 字符串，仅落库）
 */
export const importReferenceByBibtex = (data: ImportReferenceByBibtexRequest) => {
  const body: any = {
    bibtex: data.bibtex,
    // 旧参数/新参数兼容：后端以实际支持为准
    linkToFileId: data.linkToFileId,
    linkToId: data.linkToId,
    isDraft: data.isDraft ?? false,
    overwriteNote: data.overwriteNote,
    addToUserLibrary: data.addToUserLibrary,
  };

  // 过滤 undefined，避免后端对“缺省/空值”处理不一致
  Object.keys(body).forEach((k) => body[k] === undefined && delete body[k]);

  return http.post<BibtexImportResponse>("/references/import/bibtex", body);
};

/**
 * POST /api/references/import/bibtex-file
 * 导入 BibTeX 文献（multipart 统一上传端点，仅落库）
 */
export const importReferenceByBibtexFile = (data: ImportReferenceByBibtexFileRequest) => {
  const formData = new FormData();
  if (data.file) formData.append("file", data.file);

  const params: any = {
    isDraft: data.isDraft ?? false,
    overwriteNote: data.overwriteNote,
    addToUserLibrary: data.addToUserLibrary,
  };

  Object.keys(params).forEach((k) => params[k] === undefined && delete params[k]);

  return http.post<BibtexImportResponse>(
    "/references/import/bibtex-file",
    formData,
    {
      params,
      headers: { "Content-Type": "multipart/form-data" },
    },
  );
};

/**
 * POST /api/references/import/ris
 * 导入 RIS 文献（JSON 字符串，仅落库）
 */
export const importReferenceByRis = (data: ImportReferenceByRisRequest) => {
  const body: any = {
    ris: data.ris,
    // 旧参数/新参数兼容：后端以实际支持为准
    linkToFileId: data.linkToFileId,
    linkToId: data.linkToId,
    isDraft: data.isDraft ?? false,
    overwriteNote: data.overwriteNote,
    addToUserLibrary: data.addToUserLibrary,
  };

  // 过滤 undefined，避免后端对“缺省/空值”处理不一致
  Object.keys(body).forEach((k) => body[k] === undefined && delete body[k]);

  return http.post<BibtexImportResponse>("/references/import/ris", body);
};

/**
 * POST /api/references/import/ris-file
 * 导入 RIS 文献（multipart 统一上传端点，仅落库）
 */
export const importReferenceByRisFile = (
  data: ImportReferenceByRisFileRequest,
) => {
  const formData = new FormData();
  if (data.file) formData.append("file", data.file);

  const params: any = {
    isDraft: data.isDraft ?? false,
    overwriteNote: data.overwriteNote,
    addToUserLibrary: data.addToUserLibrary,
  };

  Object.keys(params).forEach((k) => params[k] === undefined && delete params[k]);

  return http.post<BibtexImportResponse>(
    "/references/import/ris-file",
    formData,
    {
      params,
      headers: { "Content-Type": "multipart/form-data" },
    },
  );
};

/**
 * POST /api/library/items
 * 新增用户文献库项（返回创建结果，状态码 201）
 */
export const upsertUserLibraryItem = (data: UpsertUserLibraryItemRequest) => {
  return http.post<UserLibraryItem>("/library/items", {
    workId: data.workId,
    note: data.note,
    collectionIds: data.collectionIds,
  });
};

/**
 * GET /api/library/items
 * 查询用户文献库项列表
 */
export const getUserLibraryItems = (params: GetUserLibraryItemsQuery = {}) => {
  const { page = 0, size = 10, keyword, itemType, yearFrom, yearTo } = params;
  return http.get<UserLibraryItem[]>("/library/items", {
    params: qp({ page, size, keyword, itemType, yearFrom, yearTo }),
  });
};

/**
 * PUT /api/library/items/{id}
 * 修改用户文献库项
 * @param id 文献库项ID
 * @param data 新增/修改用户文献库项请求
 */
export const updateUserLibraryItem = (
  id: number,
  data: UpsertUserLibraryItemRequest,
) => {
  return http.put<UserLibraryItem>(`/library/items/${id}`, {
    workId: data.workId,
    note: data.note,
    collectionIds: data.collectionIds,
  });
};

/**
 * DELETE /api/library/items/{id}
 * 删除用户文献库项
 * @param id 文献库项ID
 * @param config axios 请求配置（默认 {_silent: true} 以兼容 204）
 */
export const deleteUserLibraryItem = (
  id: number,
  config: { _silent?: boolean } = { _silent: true },
) => {
  return http.delete<DeleteUserLibraryItemResponse>(
    `/library/items/${id}`,
    config as any,
  );
};

/**
 * DELETE /api/library/items/batch
 * 批量删除用户文献库项
 */
export const batchDeleteUserLibraryItems = (
  ids: number[],
  config: { _silent?: boolean } = { _silent: true },
) => {
  return http.delete<DeleteUserLibraryItemResponse>(
    `/library/items/batch`,
    { ...config, data: { ids } } as any,
  );
};

/**
 * POST /api/library/collections
 * 新增文献集
 */
export const createUserLibraryCollection = (
  data: UpsertUserLibraryCollectionRequest,
) => {
  return http.post<UserLibraryCollectionItem>("/library/collections", {
    name: data.name,
    description: data.description,
  });
};

/**
 * GET /api/library/collections
 * 查询文献集列表
 */
export const getUserLibraryCollections = (
  params: GetUserLibraryCollectionsQuery = {},
) => {
  const { page = 0, size = 10, keyword } = params;
  return http.get<UserLibraryCollectionItem[]>("/library/collections", {
    params: qp({ page, size, keyword }),
  });
};

/**
 * PUT /api/library/collections/{id}
 * 修改文献集
 * @param id 文献集ID
 * @param data 新增/修改文献集请求
 */
export const updateUserLibraryCollection = (
  id: number,
  data: UpsertUserLibraryCollectionRequest,
) => {
  return http.put<UserLibraryCollectionItem>(`/library/collections/${id}`, {
    name: data.name,
    description: data.description,
  });
};

/**
 * POST /api/library/collections/{collectionId}/documents
 * 新增文献集子列表项
 * @param collectionId 文献集ID
 * @param data 新增文献集子列表项请求
 */
export const createUserLibraryCollectionDocument = (
  collectionId: number,
  data: UpsertUserLibraryCollectionDocumentRequest,
) => {
  return http.post<UserLibraryCollectionDocumentItem>(
    `/library/collections/${collectionId}/documents`,
    {
      workId: data.workId,
    },
  );
};

/**
 * GET /api/library/collections/{collectionId}/documents
 * 查询文献集子列表
 * @param collectionId 文献集ID
 * @param params 分页参数
 */
export const getUserLibraryCollectionDocuments = (
  collectionId: number,
  params: GetUserLibraryCollectionDocumentsQuery = {},
) => {
  const { page = 0, size = 10 } = params;
  return http.get<UserLibraryCollectionDocumentItem[]>(
    `/library/collections/${collectionId}/documents`,
    {
      params: qp({ page, size }),
    },
  );
};

/**
 * DELETE /api/library/collections/{id}
 * 删除文献集
 * @param id 文献集ID
 */
export const deleteUserLibraryCollection = (
  id: number,
  config: { _silent?: boolean } = { _silent: true },
) => {
  return http.delete<DeleteUserLibraryCollectionResponse>(
    `/library/collections/${id}`,
    config as any,
  );
};

/**
 * DELETE /api/library/collections/batch
 * 批量删除文献集
 * @param ids 文献集ID列表
 */
export const batchDeleteUserLibraryCollections = (
  ids: number[],
  config: { _silent?: boolean } = { _silent: true },
) => {
  return http.delete<DeleteUserLibraryCollectionResponse>(
    `/library/collections/batch`,
    { ...config, data: { ids } } as any,
  );
};

/**
 * DELETE /api/library/collections/{collectionId}/documents/{workId}
 * 删除文献集子列表项
 */
export const deleteUserLibraryCollectionDocument = (
  collectionId: number,
  workId: number,
  config: { _silent?: boolean } = { _silent: true },
) => {
  return http.delete<DeleteUserLibraryCollectionDocumentResponse>(
    `/library/collections/${collectionId}/documents/${workId}`,
    config as any,
  );
};

/**
 * DELETE /api/library/collections/{collectionId}/documents/batch
 * 批量删除文献集子列表项
 */
export const batchDeleteUserLibraryCollectionDocuments = (
  collectionId: number,
  workIds: number[],
  config: { _silent?: boolean } = { _silent: true },
) => {
  return http.delete<DeleteUserLibraryCollectionDocumentResponse>(
    `/library/collections/${collectionId}/documents/batch`,
    { ...config, data: { workIds } } as any,
  );
};