/**
 * 建档模块 接口适配层（2026-10-11 新版接口）
 * ------------------------------------------------------------------
 * 新版后端把「新增 / 修改」合并成一个 insertOrUpdate 接口，请求体是
 * 主表字段 + 详情表字段的扁平混合，一次调用同时维护两张表，并返回主表 ID。
 * 因此这里不再做「主表一次请求 + 详情表一次请求」的拆分，只负责：
 *   1. 前端单一档案对象 <-> 后端扁平字段的转换
 *   2. 量表 / 可编辑表格数据的 JSON 打包与解包
 *
 * 对外函数签名与旧版保持一致，页面无需改动。
 */

import {
  ARCHIVE_TYPE_CODE,
  resolveTarget,
  resolveKey,
  toApiFields,
  fromApiFields,
  toApiParent,
  packJson,
  unpackJson,
  splitLearningForm,
  normalizeDates,
  FORM_FIELD_BY_TAB,
  archiveApi,
  nowDateTime,
  today,
  toDateTime,
  calcAge,
} from "@/api/patient/archive";
import { getTypeByKey } from "./types";

/* ==================== 内部工具 ==================== */

function pick(obj, keys) {
  const out = {};
  keys.forEach((k) => {
    const v = obj && obj[k];
    if (v !== undefined && v !== null && v !== "") out[k] = v;
  });
  return out;
}

/** 后端字段 -> 前端字段（列表行、详情记录共用）
 * 注意：appointmentSituation 不在这里，它存的是 JSON 串，由 parseAppointmentStatus 单独解析
 */
const API_TO_FRONT = {
  highRiskChildType: "highriskCategory",
  highRiskChildName: "highriskName",
  nutritionIcd10Code: "nutritionCode",
  nutritionDiagName: "nutritionName",
  plannedFollowTime: "followupDate",
  birthWeight: "birthWeight",
  gestationalWeek: "gestationalWeek",
  pregnancySituation: "pregnancyStatus",
  followupCycleTimes: "followupCycles",
};

/**
 * 解析「预约情况」
 * 后端这个字段存的是 JSON 串：{"appointmentStatus":"无预约"}，
 * 直接铺到列表上会把整串 JSON 显示出来，这里统一取里面的 appointmentStatus。
 * 已经是纯文本时原样返回，解析不出内容则返回空。
 */
function parseAppointmentStatus(val) {
  if (val === undefined || val === null || val === "") return "";
  if (typeof val !== "string") return val.appointmentStatus || "";
  const s = val.trim();
  if (s.charAt(0) !== "{") return s;
  try {
    const o = JSON.parse(s);
    return (o && o.appointmentStatus) || "";
  } catch (e) {
    return "";
  }
}

/* ------------------------------------------------------------------
 * 模块名口径不一致的统一入口
 * 页面（types.js）用 maternal|child，接口层（ARCHIVE_TYPE_CODE）用 maternity|child。
 * 两边不统一会导致 resolveKey 匹配不上，列表页所有专案都识别不出来。
 */
function innerModule(module) {
  return module === "child" ? "child" : "maternity";
}

/** 接口层模块名 -> 页面口径 */
function frontModule(module) {
  return module === "child" ? "child" : "maternal";
}

/** 详情表冗余的患者基本信息 -> 前端对象 */
function applyCommonFields(target, row) {
  const front = fromApiFields(row);
  Object.keys(front).forEach((k) => {
    // id / detailId / subType 属于骨架自身的字段，不能被原始行数据覆盖
    if (k === "id" || k === "detailId" || k === "subType") return;
    const v = front[k];
    if (v !== undefined && v !== null && v !== "") target[k] = v;
  });
  Object.keys(API_TO_FRONT).forEach((apiKey) => {
    const v = row[apiKey];
    if (v !== undefined && v !== null && v !== "") target[API_TO_FRONT[apiKey]] = v;
  });
  if (row.appointmentSituation) {
    target.appointmentStatus = parseAppointmentStatus(row.appointmentSituation);
  }
  if (row.birthdate) target.age = calcAge(row.birthdate);
  if (row.parentname || row.parentPhone || row.parentRelation) {
    target.parentInfo = Object.assign({}, target.parentInfo, {
      parentName: row.parentname || "",
      relation: row.parentRelation || "",
      parentPhone: row.parentPhone || "",
      parentIdCard: row.parentIdcardno || "",
      address: row.parentAddress || "",
    });
  }
  if (row.sourceType === "1" || row.sourceType === 1) target.sourcePage = "outpatient";
  return target;
}

/**
 * 后端行 -> 前端档案对象骨架
 *
 * ⚠️ id 与 archiveid 是两个独立字段，不能互相赋值，必须由调用方显式声明这一行来自哪张表：
 *   from='main'   主表行（列表接口返回）：row.id 是主表主键，没有 archiveid
 *   from='detail' 详情行（详情接口返回）：row.id 是详情表主键，row.archiveid 是主表 ID
 *
 * 前端对象上：
 *   archive.id       永远 = 主表主键
 *   archive.detailId 永远 = 详情表主键（只有详情行才有）
 *
 * @param {Object} row 后端行
 * @param {String} typeKey 专案 key
 * @param {String} module maternity|child
 * @param {String} from main|detail 这一行的来源表
 */
function skeletonFrom(row, typeKey, module, from) {
  const t = ARCHIVE_TYPE_CODE[typeKey] || {};
  const typeCfg = getTypeByKey(typeKey) || {};
  const isDetail = from === "detail";
  const archive = {
    // 主表主键：主表行直接取 row.id；详情行取外键 row.archiveid
    id: isDetail ? row.archiveid : row.id,
    // 详情表主键：只有详情行才有，主表行（列表）拿不到，保持为空
    detailId: isDetail ? row.id : "",
    subType: typeKey,
    subTypeLabel: typeCfg.subTypeLabel || t.label || "",
    mainCategory: frontModule(module),
    mainCategoryLabel: frontModule(module) === "child" ? "儿保科建档" : "妇保科建档",
    sourcePage: "",
    parentInfo: {},
    archiveForm: {},
  };
  return applyCommonFields(archive, row);
}

/** 列表行（主表行） -> 前端档案对象 */
function normalizeRow(row, module) {
  const inner = innerModule(module);
  const key = resolveKey(inner, row.archiveType) || "";
  return skeletonFrom(row, key, inner, "main");
}

/* ------------------------------------------------------------------
 * 主表行缓存
 * 列表接口只返回主表行（不含详情主键），详情接口按主表 ID 查，两者用主表 id 就能串起来。
 * 把列表行按主表 id 暂存到 sessionStorage，getArchive 取不到详情时用它兜底，
 * 至少能把姓名、性别、诊断、联系方式这些主表字段显示出来，而不是一片空白。
 */
const ROW_PREFIX = "archiveRow:";

function cacheRows(rows = []) {
  try {
    rows.forEach((r) => {
      // 列表行是主表行，主键只认 row.id；不要用 archiveid 兜底，主表行根本没有这个字段
      const id = r.id;
      if (id) sessionStorage.setItem(ROW_PREFIX + id, JSON.stringify(r));
    });
  } catch (e) {
    /* 忽略隐私模式等写入异常 */
  }
}

function readRow(id) {
  if (!id) return null;
  try {
    return JSON.parse(sessionStorage.getItem(ROW_PREFIX + id) || "null");
  } catch (e) {
    return null;
  }
}

/* ------------------------------------------------------------------
 * 新建草稿缓存
 * 详情接口按【主表 ID】查询，但 insertOrUpdate 刚返回主表 ID 时后端详情行可能还没落好，
 * 新建完立刻跳详情页有概率取不到详情记录。这里把新建时的档案对象暂存到
 * sessionStorage，getArchive 取不到详情时用它兜底，避免详情页一片空白。
 * 保存成功后清除。
 */
const DRAFT_PREFIX = "archiveDraft:";

function saveDraft(id, archive) {
  if (!id) return;
  try {
    sessionStorage.setItem(DRAFT_PREFIX + id, JSON.stringify(archive));
  } catch (e) {
    /* 忽略隐私模式等写入异常 */
  }
}

function readDraft(id) {
  if (!id) return null;
  try {
    return JSON.parse(sessionStorage.getItem(DRAFT_PREFIX + id) || "null");
  } catch (e) {
    return null;
  }
}

function clearDraft(id) {
  if (!id) return;
  try {
    sessionStorage.removeItem(DRAFT_PREFIX + id);
  } catch (e) {
    /* ignore */
  }
}

/* ==================== 前端对象 -> 扁平 payload ==================== */

/**
 * 构造 insertOrUpdate 的请求体（主表 + 详情表字段扁平混合）
 * @param {Object} archive 前端档案对象
 * @param {Object} t resolveTarget 结果
 * @param {Boolean} forUpdate 是否更新（带 archiveid / id）
 */
export function buildPayload(archive, t, forUpdate) {
  const key = archive.subType;
  const F = FORM_FIELD_BY_TAB[key] || {};
  const payload = toApiFields(archive);

  payload.archiveType = t.archiveType;
  if (forUpdate) {
    // 扁平请求体里这两个字段各自代表一张表的主键，值来源不同，不能互相顶替：
    //   archiveid = 主表 ID（来自 archive.id）
    //   id        = 详情表主键（来自 archive.detailId，列表接口不返回，取不到就不传，后端按新增处理）
    if (archive.id) payload.archiveid = archive.id;
    if (archive.detailId) payload.id = archive.detailId;
  }
  if (archive.sourcePage === "outpatient") payload.sourceType = "1";

  // 冗余的患者基本信息：详情表也存一份
  const common = pick(archive, [
    "outhospno", "inhospno", "serialnum", "patid", "patname", "sex",
    "deptcode", "deptname", "wardcode", "wardname",
    "icd10code", "diagname", "idcardno",
  ]);
  Object.assign(payload, common, {
    birthdate: toDateTime(archive.birthday),
    diagTime: toDateTime(archive.diagnosisDate),
    archiveTime: toDateTime(archive.createTime),
    doctorName: archive.attendingDoctor || "",
    managementDoctorName: archive.managingDoctor || "",
    registerUser: archive.registrant || "",
    closeStatus: archive.closeStatus == null ? "0" : String(archive.closeStatus),
  });

  if (key === "pregnancy") {
    const p = archive.pregFormData || {};
    const reg = p.registration || {};
    const preg = p.pregnancy || {};
    const fv = p.firstVisit || {};
    Object.assign(payload, {
      lastMenstrualTime: toDateTime(fv.lmp),
      firstDoctorName: fv.firstDoctor || "",
      contactPhone: fv.contactPhone || fv.selfPhone || "",
      address: fv.address || "",
      pregnancySituation: archive.pregnancyStatus || "",
      specificSituation: packJson(preg.details || []),
      handleSuggestion: packJson(preg.hint || []),
      isRecordEstablished: reg.isRegistered === "是" ? "1" : reg.isRegistered === "否" ? "0" : "",
      dueDate: toDateTime(reg.edd),
      followupPeriod: packJson(p.followupCycle || []),
      [F.followup]: packJson(p),
    });
  } else if (key === "menopause") {
    const f = archive.formData || {};
    Object.assign(payload, {
      [F.sysQ]: packJson(f.menoSysQ || {}),
      [F.mhtFirst]: packJson(f.mhtFirst || {}),
      [F.mhtFollow]: packJson(f.mhtFollow || {}),
      [F.kupperman]: packJson(f.kupperman || {}),
      [F.mrs]: packJson(f.mrs || {}),
      [F.psqi]: packJson(f.psqi || {}),
    });
  } else if (key === "highrisk") {
    Object.assign(payload, toApiParent(archive.parentInfo || {}), {
      highRiskChildType: archive.highriskCategory || "",
      highRiskChildName: archive.highriskName || "",
      plannedFollowTime: toDateTime(archive.followupDate),
      [F.growth]: packJson(archive.growthData || []),
      [F.neuro]: packJson(archive.neuroData || []),
      [F.intervention]: packJson(archive.interventionData || []),
    });
  } else if (key === "nutrition") {
    Object.assign(payload, toApiParent(archive.parentInfo || {}), {
      nutritionDiagName: archive.nutritionName || "",
      nutritionIcd10Code: archive.nutritionCode || "",
      [F.measure]: packJson(archive.measureData || []),
      [F.diet]: packJson(archive.dietData || []),
      [F.plan]: packJson(archive.planData || []),
    });
  } else if (key === "learning") {
    const ld =
      (archive.archiveForm && archive.archiveForm.learningData) || archive.archiveForm || {};
    Object.assign(
      payload,
      toApiParent(archive.parentInfo || {}),
      splitLearningForm(ld, archive.appointmentStatus || "")
    );
  }

  delete payload.age;
  return normalizeDates(payload);
}

/* ==================== 详情记录 -> 页面表单数据 ==================== */

/** 把详情表 TEXT 字段还原成页面表单数据 */
function applyDetailToForms(archive, detail) {
  const key = archive.subType;
  const F = FORM_FIELD_BY_TAB[key] || {};

  if (key === "pregnancy") {
    const early = unpackJson(detail.epEarlyPregnancyFollowupForm, null);
    archive.pregFormData = early || {};
    if (!archive.pregFormData.followupCycle) {
      archive.pregFormData.followupCycle = unpackJson(detail.followupPeriod, []);
    }
    if (!archive.pregFormData.pregnancy) {
      archive.pregFormData.pregnancy = {
        status: "",
        details: unpackJson(detail.specificSituation, []),
        hint: unpackJson(detail.handleSuggestion, []),
      };
    }
    if (!archive.pregFormData.registration) archive.pregFormData.registration = {};
    if (detail.isRecordEstablished != null && detail.isRecordEstablished !== "") {
      archive.pregFormData.registration.isRegistered =
        detail.isRecordEstablished === "1" ? "是" : "否";
    }
    if (detail.dueDate && !archive.pregFormData.registration.edd) {
      archive.pregFormData.registration.edd = String(detail.dueDate).substring(0, 10);
    }
    if (detail.lastMenstrualTime && !archive.pregFormData.firstVisit) {
      archive.pregFormData.firstVisit = {
        lmp: String(detail.lastMenstrualTime).substring(0, 10),
      };
    }
  } else if (key === "menopause") {
    archive.formData = {
      menoSysQ: unpackJson(detail.mhiMenopauseFollowupSystemIssuesForm, {}),
      mhtFirst: unpackJson(detail.mhiMhtInitialVisitMedicalRecordForm, {}),
      mhtFollow: unpackJson(detail.mhiMhtFollowUpMedicalRecordForm, {}),
      kupperman: unpackJson(detail.mhiModifiedKuppermanScoringScaleForm, {}),
      mrs: unpackJson(detail.mhiMenopauseRatingScaleForm, {}),
      psqi: unpackJson(detail.mhiPittsburghSleepQualityIndexForm, {}),
    };
  } else if (key === "highrisk") {
    archive.growthData = unpackJson(detail.hrcGrowthDevelopmentMonitoring, []);
    archive.neuroData = unpackJson(detail.hrcNeurologicalEvaluation, []);
    archive.interventionData = unpackJson(detail.hrcInterventionRecords, []);
  } else if (key === "nutrition") {
    archive.measureData = unpackJson(detail.ndPhysicalMeasurements, []);
    archive.dietData = unpackJson(detail.ndDietaryAssessment, []);
    archive.planData = unpackJson(detail.ndInterventionProgram, []);
  } else if (key === "learning") {
    const appt = unpackJson(detail.appointmentSituation, {});
    const ability = unpackJson(detail.ldLearningAbilityAssessment, {});
    const behavior = unpackJson(detail.ldBehavioralAssessment, {});
    const train = unpackJson(detail.ldInterventionTrainingRecord, {});
    archive.appointmentStatus = appt.appointmentStatus || "";
    archive.archiveForm = {
      learningData: Object.assign({}, ability, behavior, train),
    };
  }
}

/* ==================== 查询 ==================== */

/**
 * 分页查询某专案档案（自动带上 archiveType）
 * @param {String} typeKey 专案 key
 * @param {Object} params 查询条件，支持 params.beginTime / params.endTime
 * @returns Promise<{ rows, total }>
 */
export function listArchives(typeKey, params = {}) {
  const t = resolveTarget(typeKey);
  if (!t) return Promise.resolve({ rows: [], total: 0 });
  const api = archiveApi(typeKey);
  const query = Object.assign({}, params, { archiveType: t.archiveType });
  return api.list(query).then((res) => {
    const rows = res.rows || [];
    cacheRows(rows);
    return {
      rows: rows.map((r) => normalizeRow(r, t.module)),
      total: res.total || 0,
    };
  });
}

/**
 * 按科室查询全部专案（妇保 / 儿保总列表页用，不带 archiveType）
 * @param {String} module maternal|child
 */
export function listArchivesByModule(module, params = {}) {
  const isChild = innerModule(module) === "child";
  // 两个模块共用一个控制器，取任一专案 key 只是为了拿到接口
  const api = archiveApi(isChild ? "highrisk" : "pregnancy");
  return api.list(Object.assign({}, params)).then((res) => {
    const rows = res.rows || [];
    cacheRows(rows);
    return {
      rows: rows.map((r) => normalizeRow(r, module)),
      total: res.total || 0,
    };
  });
}

/**
 * 查询单个档案详情，返回前端完整对象
 * @param {String} typeKey 专案 key
 * @param {String|Number} id 主表 ID（详情接口 getInfo/{archiveid} 就是按它查的）
 * @param {String|Number} [detailId] 已废弃，保留只为兼容旧调用，不再参与请求
 * @returns Promise<前端档案对象 | null>
 */
export function getArchive(typeKey, id, detailId) {
  const t = resolveTarget(typeKey);
  if (!t || !id) return Promise.resolve(null);
  const api = archiveApi(typeKey);

  return api
    .getDetail(id)
    .then((res) => {
      const detail = res.data || res;
      if (!detail || !detail.id) return fallbackArchive(typeKey, id, t);
      // 详情记录里的 archiveid 必须等于当前主表 id，否则说明数据串了，宁可不要
      if (detail.archiveid != null && String(detail.archiveid) !== String(id)) {
        console.warn(
          "[archive] 详情记录与主表 id 不匹配，已忽略详情数据：",
          { archiveid: detail.archiveid, expectId: id }
        );
        return fallbackArchive(typeKey, id, t);
      }
      // 详情行：row.id 是详情主键 -> detailId，row.archiveid 是主表 ID -> id
      const archive = skeletonFrom(detail, typeKey, t.module, "detail");
      applyDetailToForms(archive, detail);
      return archive;
    })
    .catch(() => fallbackArchive(typeKey, id, t));
}

/** 详情取不到时的兜底：新建草稿 > 主表行缓存 > 仅带主表 id 的空档案 */
function fallbackArchive(typeKey, id, t) {
  const cached = readDraft(id);
  if (cached && cached.subType === typeKey) {
    return Object.assign(emptyArchive(typeKey, id, t), cached, { id });
  }
  const row = readRow(id);
  if (row) return skeletonFrom(row, typeKey, t.module, "main");
  return emptyArchive(typeKey, id, t);
}

/** 详情取不到时的兜底：只带主表 id 的空档案，页面仍可填写并保存 */
function emptyArchive(typeKey, id, t) {
  const typeCfg = getTypeByKey(typeKey) || {};
  return {
    id,
    detailId: "",
    subType: typeKey,
    subTypeLabel: typeCfg.subTypeLabel || t.label || "",
    mainCategory: frontModule(t.module),
    mainCategoryLabel: frontModule(t.module) === "child" ? "儿保科建档" : "妇保科建档",
    sourcePage: "",
    parentInfo: {},
    archiveForm: {},
  };
}

/* ==================== 新增 ==================== */

/**
 * 由一条患者记录（门诊 / 住院 / 独立录入）建档
 * @param {Object} patient 患者记录
 * @param {String} typeKey 专案 key
 * @param {String} sourcePage outpatient|inpatient|standalone
 * @returns Promise<前端档案对象>
 */
export function createArchive(patient, typeKey, sourcePage) {
  const t = resolveTarget(typeKey);
  if (!t) return Promise.reject(new Error("未知的档案专案类型：" + typeKey));
  const api = archiveApi(typeKey);
  const now = nowDateTime();

  const draft = {
    subType: typeKey,
    patid: patient.patid || patient.id || "",
    patname: patient.patname || patient.name || "",
    sex: patient.sex,
    telcode: patient.telcode || patient.phone || "",
    idcardno: patient.idcardno || "",
    birthday: patient.birthday || patient.birthdate || patient.goday || "",
    // 门诊/住院记录里诊断日期字段名不统一（admitdate / diagTime / diagnosisDate），且可能只有日期
    diagnosisDate: patient.diagnosisDate || patient.diagTime || patient.admitdate || "",
    createTime: now,
    outhospno: patient.outhospno || "",
    inhospno: patient.inhospno || "",
    serialnum: patient.serialnum || "",
    deptcode: patient.deptcode || "",
    deptname: patient.deptname || "",
    wardcode: patient.wardcode || "",
    wardname: patient.wardname || "",
    icd10code: patient.icd10code || "",
    diagname: patient.diagname || "",
    attendingDoctor: patient.drname || "",
    registrant: localStorage.getItem("YongHuXM") || "",
    closeStatus: "0",
    sourcePage: sourcePage || "outpatient",
    parentInfo: {},
    archiveForm: {},
  };

  const payload = buildPayload(draft, t, false);
  return api.save(payload).then((res) => {
    const newId = res && res.data != null ? res.data : "";
    const typeCfg = getTypeByKey(typeKey) || {};
    const archive = Object.assign({}, draft, {
      id: newId,
      detailId: "",
      subTypeLabel: typeCfg.subTypeLabel || t.label,
      mainCategory: frontModule(t.module),
      mainCategoryLabel: frontModule(t.module) === "child" ? "儿保科建档" : "妇保科建档",
      age: calcAge(draft.birthday),
    });
    saveDraft(newId, archive);
    return archive;
  });
}

/* ==================== 保存 / 结案 / 删除 ==================== */

/**
 * 保存档案：一次 insertOrUpdate 同时更新主表与详情表
 * @param {Object} archive 前端档案对象
 * @param {Boolean} onlyCloseStatus 仅更新结案状态
 */
export function saveArchive(archive, onlyCloseStatus) {
  const key = archive.subType;
  const t = resolveTarget(key);
  if (!t || !archive.id) return Promise.reject(new Error("档案缺少 subType 或 id"));
  const api = archiveApi(key);

  if (onlyCloseStatus) {
    return api.save({ archiveid: archive.id, archiveType: t.archiveType, closeStatus: "1" });
  }
  return api.save(buildPayload(archive, t, true)).then((res) => {
    clearDraft(archive.id);
    return res;
  });
}

/** 结案 */
export function closeArchive(archive) {
  return saveArchive(archive, true);
}

/**
 * 删除档案（主表逻辑删除，详情表在同一事务里一起删）
 * @param {String} typeKey 专案 key
 * @param {Array} ids 主表 id 数组
 */
export function removeArchives(typeKey, ids) {
  const t = resolveTarget(typeKey);
  if (!t || !ids || !ids.length) return Promise.resolve();
  return archiveApi(typeKey).batchDelete(ids);
}

/** 删除档案（按行数组，自动按专案分组） */
export function removeArchiveList(rows = []) {
  const groups = {};
  rows.forEach((r) => {
    const key = r.subType || "";
    if (!key) return;
    (groups[key] = groups[key] || []).push(r.id);
  });
  return Promise.all(
    Object.keys(groups).map((key) => removeArchives(key, groups[key]))
  );
}

export { calcAge, nowDateTime, today, toDateTime };