/** 资质备案：接口定义与前后端字段适配 */

import { declareRequest } from "@cqsjjb/jjb-dva-runtime";
import { fromPageResponse, fromSingleResponse, toPageQuery } from "../../utils/enterpriseInfo/adapter";
import { apiGet, apiPost, apiPostDelete, safeAction, safePageResult } from "../../utils/enterpriseInfo/http";
import { asId, normalizeQueryIds } from "../../utils/enterpriseInfo/idUtil";
import { formatDate, toApiDate, toDayjs } from "../../utils/dateFormat";
import { parseUploadFileList, resolveUploadFileId } from "../../utils/mockUpload";

// ─── 工具 ───

const APPLY_TYPE_APPLICATION = 1;

// ─── 字段映射：列表行 ───

export function toFilingListRow(data = {}) {
  return {
    id: asId(data.id),
    filingId: data.filingId,
    filingTerritoryCode: data.filingTerritoryCode,
    filingTerritoryName: data.filingTerritoryName,
    filingUnitName: data.filingUnitName,
    filingNo: data.filingNo || (data.id ? String(data.id) : ""),
    businessScope: data.businessScope,
    filingStatusCode: data.filingStatusCode,
    filingStatusName: data.filingStatusName,
    applyTypeCode: data.applyTypeCode,
    applyTypeName: data.applyTypeName,
    changeCount: Number(data.changeCount ?? 0),
    originFilingId: asId(data.originFilingId),
    rejectReason: data.rejectReason,
    submitTime: formatDate(data.submitTime),
    approveTime: formatDate(data.approveTime),
  };
}



export function fromFilingBasicForm(values = {}) {
  const territoryName = values.filingTerritoryName || values.filingTerritoryCode;
  const unitTypeName = values.filingUnitTypeName || values.filingUnitTypeCode;
  return normalizeQueryIds({
    id: asId(values.id),
    businessScope: values.businessScope,
    filingTerritoryCode: territoryName,
    filingTerritoryName: territoryName,
    filingUnitName: values.filingUnitName,
    filingUnitTypeCode: unitTypeName,
    filingUnitTypeName: unitTypeName,
    filingNo: values.filingNo,
    registerAddress: values.registerAddress,
    officeAddress: values.officeAddress,
    creditCode: values.creditCode,
    qualCertNo: values.qualCertNo,
    legalPersonPhone: values.legalPersonPhone,
    contactPhone: values.contactPhone,
    infoDisclosureUrl: values.infoDisclosureUrl,
    fixedAssetAmount: values.fixedAssetAmount,
    workplaceArea: values.workplaceArea,
    archiveRoomArea: values.archiveRoomArea,
    fulltimeEvaluatorCount: values.fulltimeEvaluatorCount,
    registeredEngineerCount: values.registeredEngineerCount,
    unitIntro: values.unitIntro,
    attachmentUrl: values.attachmentUrl,
  });
}

// ─── 字段映射：详情 ───

export function toFilingDetail(data = {}) {
  return {
    ...data,
    materials: (data.materials || []),
    commitment: data.commitment ? toFilingCommitmentForm(data.commitment, data.filingUnitName) : null,
    personnelList: (data.personnelList || []).map(toFilingPersonnelRow),
    equipmentList: (data.equipmentList || []).map(toFilingEquipmentRow),
  };
}



// ─── 字段映射：承诺书 ───

export function parseCommitmentNames(content = "", filingUnitName = "") {
  const withComma = String(content).match(/本人是(.+?)，是(.+?)法定代表人/);
  if (withComma) {
    return {
      legalRepName: withComma[1]?.trim() || "",
      filingUnitName: withComma[2]?.trim() || filingUnitName || "",
    };
  }
  const legacy = String(content).match(/本人是(.+?)是(.+?)法定代表人/);
  return {
    legalRepName: legacy?.[1]?.trim() || "",
    filingUnitName: legacy?.[2]?.trim() || filingUnitName || "",
  };
}

export function toFilingCommitmentForm(data = {}, filingUnitName = "") {
  const parsed = parseCommitmentNames(data.commitmentContent, filingUnitName);
  const legalRepPersonnelId = data.legalRepPersonnelId ? String(asId(data.legalRepPersonnelId)) : "";
  return {
    id: asId(data.id),
    filingId: asId(data.filingId),
    commitmentContent: data.commitmentContent,
    legalRepPersonnelId,
    legalRepName: data.legalRepName || parsed.legalRepName,
    filingUnitName: parsed.filingUnitName || filingUnitName,
    legalRepSignatureUrl: data.legalRepSignatureUrl,
    signDate: toDayjs(data.signDate),
    signatureFiles: parseUploadFileList(data.legalRepSignatureUrl, "电子签名.jpg"),
  };
}

export function fromFilingCommitmentForm(values = {}, filingId) {
  const personnelId = asId(values.legalRepPersonnelId);
  return {
    id: asId(values.id),
    filingId: asId(filingId),
    commitmentContent: values.commitmentContent,
    legalRepSignatureUrl: values.legalRepSignatureUrl,
    signDate: toApiDate(values.signDate),
    legalRepPersonnelId: personnelId || null,
    legalRepName: values.legalRepName || "",
  };
}

// ─── 字段映射：人员 / 装备 ───

export function toFilingPersonnelRow(data = {}) {
  const personName = data.personName || data.userName || data.staffName;
  return {
    id: asId(data.id),
    filingId: asId(data.filingId),
    sourcePersonnelId: asId(data.sourcePersonnelId),
    personName,
    userName: personName,
    personTypeCode: data.personTypeCode,
    personTypeName: data.personTypeName,
    positionName: data.positionName,
    titleName: data.titleName,
    genderCode: data.genderCode,
    genderName: data.genderName,
    birthDate: data.birthDate,
    joinWorkDate: data.joinWorkDate,
    idCardNo: data.idCardNo,
    currentAddress: data.currentAddress,
    officeAddress: data.officeAddress,
    educationCode: data.educationCode,
    educationName: data.educationName,
    graduateSchool: data.graduateSchool,
    major: data.major,
    qualScope: data.qualScope,
    publications: data.publications,
    professionalLevelCert: data.professionalLevelCert,
    registerEngineerFlag: data.registerEngineerFlag,
    abilityDeclaration: data.abilityDeclaration,
    workExperience: data.workExperience,
    proofMaterialUrl: data.proofMaterialUrl,
  };
}

export function fromFilingPersonnelAddCmd(item = {}) {
  const row = toFilingPersonnelRow(item);
  return normalizeQueryIds({
    sourcePersonnelId: row.sourcePersonnelId,
    personName: row.personName,
    personTypeCode: row.personTypeCode,
    personTypeName: row.personTypeName,
    positionName: row.positionName,
    titleName: row.titleName,
    genderCode: row.genderCode,
    genderName: row.genderName,
    birthDate: row.birthDate,
    joinWorkDate: row.joinWorkDate,
    idCardNo: row.idCardNo,
    currentAddress: row.currentAddress,
    officeAddress: row.officeAddress,
    educationCode: row.educationCode,
    educationName: row.educationName,
    graduateSchool: row.graduateSchool,
    major: row.major,
    qualScope: row.qualScope,
    publications: row.publications,
    professionalLevelCert: row.professionalLevelCert,
    registerEngineerFlag: row.registerEngineerFlag,
    abilityDeclaration: row.abilityDeclaration,
    workExperience: row.workExperience,
    proofMaterialUrl: row.proofMaterialUrl,
  });
}

export function toFilingEquipmentRow(data = {}) {
  return {
    id: asId(data.id),
    filingId: asId(data.filingId),
    sourceEquipmentId: asId(data.sourceEquipmentId),
    deviceName: data.deviceName,
    deviceModel: data.deviceModel,
    manufacturer: data.manufacturer,
    calibrationReportUrl: data.calibrationReportUrl,
  };
}

// ─── 字段映射：变更历史 ───

export function toChangeHistory(data = {}) {
  return {
    changeCount: Number(data.changeCount ?? 0),
    records: (data.records || []).map((item, index) => ({
      id: asId(item.id),
      index: index + 1,
      changeItemName: item.changeItemName,
      changeTime: formatDate(item.changeTime),
      operatorName: item.operatorName,
    })),
  };
}



// ─── 分页查询参数映射 ───

function toFilingPageQuery(params = {}) {
  const { filingTerritoryName, filingTerritoryCode, filingStatus, ...rest } = params;
  const query = toPageQuery(rest, {
    filingUnitName: "filingUnitName",
    filingNo: "filingNo",
    applyTypeCode: "applyTypeCode",
  });
  const territory = filingTerritoryCode || filingTerritoryName;
  if (territory) {
    query.filingTerritoryCode = territory;
  }
  if (filingStatus !== undefined && filingStatus !== null && filingStatus !== "") {
    query.filingStatusCode = Number(filingStatus);
  }
  return query;
}

// ═══════════════════════════════════════════════════
// 接口 Action
// ═══════════════════════════════════════════════════

export async function fetchQualFilingDetail(id) {
  const res = await apiGet("/safetyEval/qual-filing/detail", { id: asId(id) });
  return fromSingleResponse(res, toFilingDetail);
}

export async function fetchQualChangeDetail(id) {
  const res = await apiGet("/safetyEval/qual-filing-change/detail", { id: asId(id) });
  return fromSingleResponse(res, toFilingDetail);
}

export async function fetchQualFilingChangeHistory(filingId) {
  const res = await apiGet("/safetyEval/qual-filing-change/history", {
    filingId: asId(filingId),
  });
  return fromSingleResponse(res, toChangeHistory);
}

export const qualFilingPage = declareRequest("qualFilingLoading", safePageResult(async (params) => {
  const res = await apiGet("/safetyEval/qual-filing/page", toFilingPageQuery(params));
  return fromPageResponse(res, toFilingListRow);
}));

export const qualFilingFiledPage = declareRequest("qualFilingLoading", safePageResult(async (params) => {
  const res = await apiGet("/safetyEval/qual-filing/filed/page", toFilingPageQuery(params));
  return fromPageResponse(res, toFilingListRow);
}));

export const qualFilingChangePage = declareRequest("qualFilingLoading", safePageResult(async (params) => {

  const res = await apiGet("/safetyEval/qual-filing-change/org/page", params);
  return fromPageResponse(res, toFilingListRow);
}));

export const qualFilingDraft = declareRequest("qualFilingLoading", safeAction(async () => {
  const res = await apiPost("/safetyEval/qual-filing/draft?applyTypeCode=1", {});
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingFiledDraft = declareRequest("qualFilingLoading", safeAction(async () => {
  const res = await apiPost("/safetyEval/qual-filing/filed/draft", {});
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingSaveDraft = declareRequest("qualFilingLoading", safeAction(async (values) => {
  const res = await apiPost("/safetyEval/qual-filing/save-draft", fromFilingBasicForm(values));
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingSubmit = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  const res = await apiPost(`/safetyEval/qual-filing/submit?id=${encodeURIComponent(asId(id))}`, {});
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingDelete = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  return apiPostDelete("/safetyEval/qual-filing/delete", id);
}));

export const qualFilingMaterialInitTemplate = declareRequest("qualFilingLoading", safeAction(async ({ filingId }) => {
  return apiPost(`/safetyEval/qual-filing-material/init-template?filingId=${encodeURIComponent(asId(filingId))}`, {});
}));

export const qualFilingMaterialUpload = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing-material/upload", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res);
}));

export const qualFilingUploadAttachment = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing/upload-attachment", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res, toFilingListRow);
}));

export const qualFilingCommitmentSaveOrUpdate = declareRequest("qualFilingLoading", safeAction(async (values) => {
  const payload = fromFilingCommitmentForm(values, values.filingId);
  const res = await apiPost("/safetyEval/qual-filing-commitment/save-or-update", payload);
  return fromSingleResponse(res);
}));

export const qualFilingCommitmentUploadSignature = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing-commitment/upload-signature", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res);
}));

export const qualFilingPersonnelBatchAdd = declareRequest("qualFilingLoading", safeAction(async ({ filingId, sourcePersonnelIds }) => {
  const res = await apiPost("/safetyEval/qual-filing-personnel/batch-add-from-org", {
    filingId: asId(filingId),
    sourcePersonnelIds: (sourcePersonnelIds || []).map(asId),
  });
  return res;
}));

export const qualFilingPersonnelDelete = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  return apiPostDelete("/safetyEval/qual-filing-personnel/delete", id);
}));

export const qualFilingEquipmentBatchAdd = declareRequest("qualFilingLoading", safeAction(async ({ filingId, sourceEquipmentIds }) => {
  const res = await apiPost("/safetyEval/qual-filing-equipment/batch-add-from-org", {
    filingId: asId(filingId),
    sourceEquipmentIds: (sourceEquipmentIds || []).map(asId),
  });
  return res;
}));

export const qualFilingEquipmentUploadCalibration = declareRequest("qualFilingLoading", safeAction(async ({ id, attachmentUrl, files }) => {
  const url = attachmentUrl || resolveUploadFileId(files);
  const res = await apiPost("/safetyEval/qual-filing-equipment/upload-calibration", { id: asId(id), attachmentUrl: url });
  return fromSingleResponse(res);
}));

export const qualFilingEquipmentDelete = declareRequest("qualFilingLoading", safeAction(async ({ id }) => {
  return apiPostDelete("/safetyEval/qual-filing-equipment/delete", id);
}));



export const qualFilingChangeSubmit = declareRequest("qualFilingLoading", safeAction(async ({ draftFilingId }) => {
  return apiPost("/safetyEval/qual-filing-change/submit", { draftFilingId: asId(draftFilingId) });
}));

export const submitQualFiling = declareRequest(
  "qualFilingSubmitLoading",
  "Post > @/safetyEval/qual-filing/aggregationSaveOrEdit",
);

export const submitQualFilingChange = declareRequest(
  "qualFilingSubmitLoading",
  "Post > @/safetyEval/qual-filing-change/aggregationSaveOrEdit",
);