/* -*- coding: utf-8 -*- */
/**
 * 계약 변환·계약 원가계산 (contract_calc.js) — 설계 내역 → 계약 내역(비목별 단가적용율 · 적용제외 공정 · W코드 공내역)
 * 근거: 지식DB STmate/old/20_분석 27 §2(wM_Mk_Cont 노·재·경 적용율 · 옵션 · 적용제외 · 예상적용율 찾기)
 *       · 26 §4(NAGCD 낙찰율 열 · 계약단가) · 35 §3(계약 단계) · 16 §4.5(BOQ11 설계 + BOQ12 계약)
 * 규칙(울진 2025 STC 실증): 계약 단가 = 비목별 trunc(설계 단가 × 적용율/100) · 금액 = 비목별 trunc(단가 × 수량)
 *       · 새 계약 코드 = 머리글자별 기존 최대 번호 다음부터 내역 차례 · 적용제외 공정은 코드·단가 그대로
 *       · 계약 원가계산 = 계약 직접비 위에 계약 차수 원가설정(당초액 유지 항목 고정)
 * 정답 대조: resources/tester/test_stmate_stage_contract.py (BOQ12 계약내역 · PRJLST 계약 행 · 계약 SMT)
 */
const StmateContract = (() => {
  const Calc = (typeof window !== "undefined" && window.STMATE_CALC) || require("./calc.js");
  const KF =
    (typeof window !== "undefined" && window.STMATE_KANJUB_FACTORY) || require("./kanjub_calc.js");
  const Change =
    (typeof window !== "undefined" && window.STMATE_CHANGE) || require("./change_calc.js");
  const { roundDown, roundHalfUp, roundUp } = Calc;
  const applyRoundMode = (v, mode, d = 0) =>
    mode === "up" ? roundUp(v, d) : mode === "half" ? roundHalfUp(v, d) : roundDown(v, d);
  const calcKanjub = KF(Object.assign({}, Calc, { applyRoundMode }));
  const n0 = (v) => Number(v) || 0;
  const COMPS = [
    ["m", "M", "rateM"],
    ["l", "L", "rateL"],
    ["s", "S", "rateS"],
  ];
  // 계약 원가계산에서 설계 금액을 그대로 쓰는 항목(D_ 표시) — 울진 2025 계약 SMT 실증 · 35번 §4
  const CONTRACT_CARRY = ["KUNBO", "SLVBO", "YUNBO", "TBUGUM", "ANJUN"];

  const DEFAULT_OPTS = {
    rateL: 100,
    rateM: 100,
    rateS: 100,
    digits: 0,
    excludeHeads: [],
    excludeLeaves: [],
    excludeGov: true,
    zeroToW: true,
    sameCodeSeparate: false,
  };

  // 머리글자별 기존 최대 코드 번호 — 새 계약 코드는 그 다음부터
  function codeBaseFromCostn(costnRows) {
    const base = {};
    for (const r of costnRows || []) {
      const m = /^([A-Z])(\d+)$/.exec(String(r.CODE || "").trim());
      if (m) base[m[1]] = Math.max(base[m[1]] || 0, Number(m[2]));
    }
    return base;
  }

  // 적용제외 판정 — 고른 머리 아래 전부 · 고른 공종 · (옵션) 관급 구역
  function excludedSet(tree, o) {
    const ex = new Set();
    const heads = new Set((o.excludeHeads || []).map(String));
    const leaves = new Set((o.excludeLeaves || []).map(String));
    tree.nodes.forEach((nd, i) => {
      if (nd.kind === "head" && heads.has(String(nd.recno))) {
        const end = nd.closeIdx != null ? nd.closeIdx : tree.nodes.length;
        for (let k = i; k <= end && k < tree.nodes.length; k++) ex.add(k);
      }
      if (nd.kind === "leaf") {
        if (leaves.has(String(nd.id)) || leaves.has(String(nd.recno))) ex.add(i);
        if (o.excludeGov && nd.gov) ex.add(i);
      }
    });
    return ex;
  }

  // 설계 → 계약 변환 — 행별 단가·금액과 머리 합계 · 직접비·관급 합계
  function convert(tree, opts, stage = 1, codeBase = null) {
    const o = Object.assign({}, DEFAULT_OPTS, opts || {});
    const ex = excludedSet(tree, o);
    const counter = codeBase ? Object.assign({}, codeBase) : null;
    const codeMap = {};
    const nextCode = (code) => {
      const p = code[0];
      counter[p] = (counter[p] || 0) + 1;
      return p + String(counter[p]).padStart(Math.max(5, code.length - 1), "0");
    };
    const nodes = tree.nodes.map((nd, i) => {
      const out = Object.assign({}, nd, { st: {} });
      if (nd.kind !== "leaf") return out;
      const d = nd.st[stage] || {};
      const excluded = ex.has(i);
      const unit = {};
      for (const [c, , rk] of COMPS) {
        const u = n0(d[c + "Unit"]);
        unit[c] = excluded ? u : roundDown((u * n0(o[rk])) / 100, n0(o.digits));
      }
      const qty = n0(d.qty);
      const amt = {};
      for (const [c] of COMPS) amt[c] = roundDown(unit[c] * qty, 0);
      const tUnit = unit.m + unit.l + unit.s;
      let newCode = nd.code;
      const designT = n0(d.tUnit);
      const zeroed = !excluded && o.zeroToW && designT !== 0 && tUnit === 0;
      if (!excluded && counter && nd.code) {
        const key = zeroed ? "W" + nd.code.slice(1) : nd.code;
        if (!o.sameCodeSeparate && codeMap[key]) newCode = codeMap[key];
        else {
          newCode = nextCode(zeroed ? "W" + nd.code.slice(1) : nd.code);
          codeMap[key] = newCode;
        }
      } else if (zeroed) newCode = "W" + nd.code.slice(1);
      out.excluded = excluded;
      out.zeroed = zeroed;
      out.newCode = newCode;
      out.design = d;
      out.st[stage] = {
        qty,
        mUnit: unit.m,
        lUnit: unit.l,
        sUnit: unit.s,
        tUnit,
        mAmt: amt.m,
        lAmt: amt.l,
        sAmt: amt.s,
        tAmt: amt.m + amt.l + amt.s,
      };
      return out;
    });
    nodes.forEach((nd) => nd.pct && (nd.pctQty = { [stage]: n0(nd.pctQty && nd.pctQty[stage]) }));
    Change.applyPct(nodes, [stage]);
    Change.sumHeads(nodes, [stage]);
    let directM = 0,
      directL = 0,
      directS = 0,
      govRawTotal = 0,
      govFeeTotal = 0;
    for (const nd of nodes) {
      if (nd.kind !== "leaf" || nd.missing) continue;
      const s = nd.st[stage];
      if (nd.gov) {
        if (nd.rowType === "gov_fee") govFeeTotal += s.tAmt;
        else govRawTotal += s.tAmt;
      } else ((directM += s.mAmt), (directL += s.lAmt), (directS += s.sAmt));
    }
    const directTotal = directM + directL + directS;
    const totals = { directM, directL, directS, directT: directTotal, directTotal };
    Object.assign(totals, { govRawTotal, govFeeTotal, govCombinedRaw: govRawTotal + govFeeTotal });
    return { nodes, rows: rowsOf(nodes, stage), totals, codeMap, opts: o, stage };
  }

  function rowsOf(nodes, stage) {
    return nodes
      .filter((nd) => nd.kind !== "blank")
      .map((nd) => {
        const s = nd.st[stage] || {};
        const r = { kind: nd.kind, recno: nd.recno, itnum: nd.itnum, name: nd.name };
        Object.assign(r, {
          mAmt: n0(s.mAmt),
          lAmt: n0(s.lAmt),
          sAmt: n0(s.sAmt),
          tAmt: n0(s.tAmt),
        });
        if (nd.kind === "leaf")
          Object.assign(r, {
            id: nd.id,
            code: nd.code,
            newCode: nd.newCode,
            excluded: nd.excluded,
            zeroed: nd.zeroed,
            qty: n0(s.qty),
            unit: nd.unit,
            spec: nd.spec,
            mUnit: n0(s.mUnit),
            lUnit: n0(s.lUnit),
            sUnit: n0(s.sUnit),
            tUnit: n0(s.tUnit),
            dUnit: n0(nd.design && nd.design.tUnit),
            dAmt: n0(nd.design && nd.design.tAmt),
          });
        return r;
      });
  }

  // 계약 원가설정 기본 — 설계 설정 복사 · 당초액 유지 항목은 설계 금액 고정 · 이윤율만 따로
  function defaultContractCfg(designCfg, designKj, opts = {}) {
    const cfg = JSON.parse(JSON.stringify(designCfg || {}));
    cfg.fixed = {};
    for (const c of opts.carry || CONTRACT_CARRY)
      if (designKj && designKj.itemMap[c]) cfg.fixed[c] = designKj.itemMap[c].amount;
    if (opts.iyunRate != null)
      cfg.rates = Object.assign({}, cfg.rates, { IYUN: n0(opts.iyunRate) });
    cfg.anjunAuto = 1;
    return cfg;
  }

  // 계약 원가계산서 — 계약 직접비 + 계약 원가설정
  function contractKanjub(conv, cfg) {
    return calcKanjub({ kanjubConfig: cfg }, conv.totals, null, cfg);
  }

  // 예상적용율 찾기 — 노·재·경 같은 율 · 0.001% 단위 · 목표 이하 최대
  //   what = "direct"(직접공사비) · "grand"(총공사비, cfg 필요)
  function findRate(tree, opts, target, stage = 1, what = "direct", cfg = null) {
    const value = (k) => {
      const r = k / 1000;
      const conv = convert(tree, Object.assign({}, opts, { rateL: r, rateM: r, rateS: r }), stage);
      return what === "grand" && cfg
        ? contractKanjub(conv, cfg).grandTotal
        : conv.totals.directTotal;
    };
    let lo = 0,
      hi = 100000;
    if (value(hi) <= target) return { rate: 100, value: value(hi) };
    while (hi - lo > 1) {
      const mid = (lo + hi) >> 1;
      if (value(mid) <= n0(target)) lo = mid;
      else hi = mid;
    }
    return { rate: lo / 1000, value: value(lo) };
  }

  // 적용금액 미리계산 — 비목별 설계·계약 합과 실제 적용율
  function preview(conv) {
    const d = { m: 0, l: 0, s: 0 },
      c = { m: 0, l: 0, s: 0 };
    for (const nd of conv.nodes) {
      if (nd.kind !== "leaf" || nd.gov) continue;
      for (const k of ["m", "l", "s"]) {
        d[k] += n0(nd.design && nd.design[k + "Amt"]);
        c[k] += n0(nd.st[conv.stage][k + "Amt"]);
      }
    }
    const rate = (a, b) => (a ? Math.round((b / a) * 1e7) / 1e5 : 0);
    return {
      design: d,
      contract: c,
      rates: { m: rate(d.m, c.m), l: rate(d.l, c.l), s: rate(d.s, c.s) },
      total: { design: d.m + d.l + d.s, contract: c.m + c.l + c.s },
    };
  }

  // 낙찰율 열(NAGCD) 저장값 — 새 계약 코드마다 [코드, 설계 코드, 적용율, 단가]
  function nagcdRows(conv) {
    const seen = new Set(),
      out = [];
    for (const nd of conv.nodes) {
      if (nd.kind !== "leaf" || nd.excluded || seen.has(nd.newCode)) continue;
      seen.add(nd.newCode);
      const s = nd.st[conv.stage];
      out.push({
        code: nd.newCode,
        from: nd.code,
        rates: { L: conv.opts.rateL, M: conv.opts.rateM, S: conv.opts.rateS },
        unit: [s.mUnit, s.lUnit, s.sUnit],
        design: [nd.design.mUnit, nd.design.lUnit, nd.design.sUnit],
      });
    }
    return out;
  }

  return {
    CONTRACT_CARRY,
    DEFAULT_OPTS,
    codeBaseFromCostn,
    convert,
    defaultContractCfg,
    contractKanjub,
    findRate,
    preview,
    nagcdRows,
  };
})();

if (typeof window !== "undefined") window.STMATE_CONTRACT = StmateContract;
if (typeof module !== "undefined" && module.exports) module.exports = StmateContract;