'use strict';

const db = require('../infra/db');
const sync = require('../sync/sync');

/** 与前端 export-employees.js 保持一致：六维相加为月画像分，累计取各月平均 */
const FORMULA_VERSION = 'v3';

const BASE = {
  km: 15,
  performance: 25,
  online: 15,
  practical: 15,
  fault: 10,
  incident: 10,
};

let schemaReady = false;

function normalizeEmployeeId(value) {
  const raw = String(value || '').trim();
  if (!raw) return '';
  return raw.replace(/^0+/, '') || '0';
}

function padEmployeeId(value) {
  const raw = String(value || '').trim();
  if (!raw) return '';
  if (/^\d+$/.test(raw) && raw.length <= 5) return raw.padStart(5, '0');
  return raw;
}

function idVariants(employeeId) {
  return [...new Set([
    String(employeeId || '').trim(),
    padEmployeeId(employeeId),
    normalizeEmployeeId(employeeId),
  ].filter(Boolean))];
}

function parseEmployeeIds(value) {
  if (Array.isArray(value)) {
    return value.map((item) => normalizeEmployeeId(item)).filter(Boolean);
  }
  if (value == null || value === '') return [];
  if (typeof value === 'string') {
    const text = value.trim();
    if (!text) return [];
    try {
      const parsed = JSON.parse(text);
      if (Array.isArray(parsed)) {
        return parsed.map((item) => normalizeEmployeeId(item)).filter(Boolean);
      }
    } catch (_error) { /* ignore */ }
    return text.split(/[,，;\s]+/).map((item) => normalizeEmployeeId(item)).filter(Boolean);
  }
  if (Buffer.isBuffer(value)) return parseEmployeeIds(value.toString('utf8'));
  return [normalizeEmployeeId(value)].filter(Boolean);
}

function isFaultSuccess(value) {
  return String(value ?? '').includes('成功');
}

function hasIncidentIssue(value) {
  const text = String(value ?? '').trim();
  if (!text) return false;
  if (text === '/' || text === '-' || text === '无' || text === '无问题') return false;
  return true;
}

function drivePointsValue(value) {
  const num = Number(value);
  return Number.isFinite(num) ? num : 0;
}

function round1(value) {
  return Math.round(Number(value) * 10) / 10;
}

function ymKey(year, month) {
  return `${Number(year)}-${String(Number(month)).padStart(2, '0')}`;
}

function parseYm(value) {
  if (!value) return null;
  if (value instanceof Date && !Number.isNaN(value.getTime())) {
    return { year: value.getFullYear(), month: value.getMonth() + 1 };
  }
  const text = String(value).trim();
  const match = text.match(/(\d{4})\D+(\d{1,2})/);
  if (!match) return null;
  const year = Number(match[1]);
  const month = Number(match[2]);
  if (!Number.isFinite(year) || month < 1 || month > 12) return null;
  return { year, month };
}

/**
 * 业务月：本月 21 日～下月 20 日归入「下月」（跨年进次年 1 月）。
 * 仅用于绩效考核/嘉奖 assessment_date。
 * 例：2025-12-21 → 2026-01；2025-12-20 → 2025-12。
 */
function calendarPartsShanghai(value) {
  if (value == null || value === '') return null;
  if (typeof value === 'string') {
    const dateOnly = value.match(/^(\d{4})-(\d{2})-(\d{2})/);
    if (dateOnly) {
      return {
        year: Number(dateOnly[1]),
        month: Number(dateOnly[2]),
        day: Number(dateOnly[3]),
      };
    }
  }
  const date = value instanceof Date ? value : new Date(value);
  if (Number.isNaN(date.getTime())) return null;
  const formatted = new Intl.DateTimeFormat('en-CA', {
    timeZone: 'Asia/Shanghai',
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
  }).format(date);
  const matched = formatted.match(/^(\d{4})-(\d{2})-(\d{2})$/);
  if (!matched) return null;
  return {
    year: Number(matched[1]),
    month: Number(matched[2]),
    day: Number(matched[3]),
  };
}

function parseBusinessYm(value) {
  const parts = calendarPartsShanghai(value);
  if (!parts) return null;
  let { year, month, day } = parts;
  if (day >= 21) {
    month += 1;
    if (month > 12) {
      month = 1;
      year += 1;
    }
  }
  if (!Number.isFinite(year) || month < 1 || month > 12) return null;
  return { year, month };
}

/** 自然月：按故障/事故发生日期的日历年月归桶（上海时区） */
function parseCalendarYm(value) {
  const parts = calendarPartsShanghai(value);
  if (!parts) return parseYm(value);
  return { year: parts.year, month: parts.month };
}

function monthRange(start, end) {
  const out = [];
  if (!start || !end) return out;
  let y = start.year;
  let m = start.month;
  const endKey = ymKey(end.year, end.month);
  while (ymKey(y, m) <= endKey) {
    out.push({ year: y, month: m });
    m += 1;
    if (m > 12) { m = 1; y += 1; }
  }
  return out;
}

function earlierYm(a, b) {
  if (!a) return b;
  if (!b) return a;
  return ymKey(a.year, a.month) <= ymKey(b.year, b.month) ? a : b;
}

function extractRemarks(details) {
  if (details == null || details === '') return '';
  let obj = details;
  if (typeof details === 'string') {
    try { obj = JSON.parse(details); } catch (_e) { return ''; }
  }
  if (Buffer.isBuffer(details)) {
    try { obj = JSON.parse(details.toString('utf8')); } catch (_e) { return ''; }
  }
  return String(obj?.remarks || '').trim();
}

/**
 * 备注含「组长」（含后备班组长、组长/施工负责人等）→ 公里分可按班组均值保底。
 * 仅写「施工负责人」、不含「组长」的不适用。
 */
function usesTeamAvgKm(remarks) {
  const text = String(remarks || '').trim();
  if (!text) return false;
  return text.includes('组长');
}

function recalcTotalScore(metrics) {
  return round1(
    (Number(metrics.kmScore) || 0)
    + (Number(metrics.performanceScore) || 0)
    + (Number(metrics.onlineExam) || 0)
    + (Number(metrics.practicalExam) || 0)
    + (Number(metrics.faultScore) || 0)
    + (Number(metrics.incidentScore) || 0),
  );
}

function computeMonthScores(parts) {
  const kmAnomalyCount = Number(parts.kmAnomalyCount) || 0;
  // 无公里数据按 0 分；有数据则满分 15，异常一次扣 5
  const kmScore = parts.hasKm
    ? Math.max(0, round1(BASE.km - 5 * kmAnomalyCount))
    : 0;

  const performanceDeduction = Number(parts.performanceDeduction) || 0;
  const drivingDeduction = Number(parts.drivingDeduction) || 0;
  const performanceScore = Math.max(
    0,
    round1((BASE.performance - performanceDeduction) * (1 - 0.1 * drivingDeduction)),
  );

  // 有成绩：均分×0.15；缺考且无成绩：0；该月无考试记录：基础 15
  let onlineExam = BASE.online;
  if (parts.hasOnline) {
    onlineExam = Math.max(0, round1(Number(parts.onlineAvg) * 0.15));
  } else if (parts.hasMissingOnline) {
    onlineExam = 0;
  }
  const practicalExam = parts.hasPractical
    ? Math.max(0, round1(Number(parts.practicalAvg) * 0.15))
    : BASE.practical;

  let faultScore = BASE.fault;
  const faultSuccessCount = Number(parts.faultSuccessCount) || 0;
  const faultTotalCount = Number(parts.faultTotalCount) || 0;
  if (faultTotalCount > 0) {
    faultScore = Math.max(0, round1(BASE.fault + 2 * faultSuccessCount));
  }

  let incidentScore = BASE.incident;
  const incidentOkCount = Number(parts.incidentOkCount) || 0;
  const incidentIssueCount = Number(parts.incidentIssueCount) || 0;
  const incidentTotalCount = incidentOkCount + incidentIssueCount;
  if (incidentTotalCount > 0) {
    incidentScore = Math.max(
      0,
      round1(BASE.incident + 5 * incidentOkCount - 10 * incidentIssueCount),
    );
  }

  const totalScore = round1(
    kmScore + performanceScore + onlineExam + practicalExam + faultScore + incidentScore,
  );

  return {
    kmScore,
    kmAnomalyCount,
    performanceScore,
    performanceDeduction,
    drivingDeduction,
    onlineExam,
    practicalExam,
    faultScore,
    faultSuccessCount,
    incidentScore,
    incidentOkCount,
    incidentIssueCount,
    totalScore,
  };
}

async function ensureSchema() {
  if (schemaReady) return;
  await db.execute(`
    CREATE TABLE IF NOT EXISTS crew_metrics_employee_yearly (
      id                  BIGINT AUTO_INCREMENT PRIMARY KEY,
      year                INT NOT NULL,
      employee_id         VARCHAR(20) NOT NULL,
      km_score            DECIMAL(8,2) NOT NULL DEFAULT 12,
      km_anomaly_count    INT NOT NULL DEFAULT 0,
      performance_score   DECIMAL(8,2) NOT NULL DEFAULT 100,
      performance_deduction DECIMAL(10,2) NOT NULL DEFAULT 0,
      driving_score       DECIMAL(8,2) NOT NULL DEFAULT 12,
      driving_deduction   DECIMAL(10,2) NOT NULL DEFAULT 0,
      online_exam         DECIMAL(8,2) NOT NULL DEFAULT 0,
      practical_exam      DECIMAL(8,2) NOT NULL DEFAULT 0,
      fault_score         DECIMAL(8,2) NOT NULL DEFAULT 80,
      incident_score      DECIMAL(8,2) NOT NULL DEFAULT 100,
      total_score         DECIMAL(8,2) NOT NULL DEFAULT 0,
      formula_version     VARCHAR(16) NOT NULL DEFAULT 'v1',
      computed_at         DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
      version             BIGINT NOT NULL DEFAULT 0,
      UNIQUE KEY uk_employee_year (employee_id, year),
      KEY idx_year_total (year, total_score)
    ) ENGINE=InnoDB
  `);
  await db.execute(`
    CREATE TABLE IF NOT EXISTS crew_metrics_employee_monthly (
      id                    BIGINT AUTO_INCREMENT PRIMARY KEY,
      year                  INT NOT NULL,
      month                 TINYINT NOT NULL,
      employee_id           VARCHAR(20) NOT NULL,
      km_score              DECIMAL(8,2) NOT NULL DEFAULT 15,
      km_anomaly_count      INT NOT NULL DEFAULT 0,
      performance_score     DECIMAL(8,2) NOT NULL DEFAULT 25,
      performance_deduction DECIMAL(10,2) NOT NULL DEFAULT 0,
      driving_deduction     DECIMAL(10,2) NOT NULL DEFAULT 0,
      online_exam           DECIMAL(8,2) NOT NULL DEFAULT 15,
      practical_exam        DECIMAL(8,2) NOT NULL DEFAULT 15,
      fault_score           DECIMAL(8,2) NOT NULL DEFAULT 10,
      fault_success_count   INT NOT NULL DEFAULT 0,
      incident_score        DECIMAL(8,2) NOT NULL DEFAULT 10,
      incident_ok_count     INT NOT NULL DEFAULT 0,
      incident_issue_count  INT NOT NULL DEFAULT 0,
      total_score           DECIMAL(8,2) NOT NULL DEFAULT 100,
      formula_version       VARCHAR(16) NOT NULL DEFAULT 'v2',
      computed_at           DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
      version               BIGINT NOT NULL DEFAULT 0,
      UNIQUE KEY uk_employee_year_month (employee_id, year, month),
      KEY idx_year_month_total (year, month, total_score),
      KEY idx_employee_total (employee_id, total_score)
    ) ENGINE=InnoDB
  `);
  await db.execute(
    `INSERT IGNORE INTO sync_table_versions (table_name, version) VALUES
       ('crew_metrics_employee_yearly', 0),
       ('crew_metrics_employee_monthly', 0)`,
  );
  schemaReady = true;
}

function rowMatchesEmployee(ids, targetVariants) {
  const normalizedTargets = new Set(targetVariants.map(normalizeEmployeeId));
  return ids.some((id) => normalizedTargets.has(id));
}

function pushBucket(map, year, month, init) {
  const key = ymKey(year, month);
  if (!map.has(key)) map.set(key, typeof init === 'function' ? init() : { ...init });
  return map.get(key);
}

async function loadEmployeeContext(employeeId) {
  const variants = idVariants(employeeId);
  const canonicalId = padEmployeeId(employeeId) || String(employeeId).trim();
  const placeholders = variants.map(() => '?').join(',');
  if (!placeholders) {
    return {
      canonicalId,
      variants,
      hireYm: null,
      team: '',
      remarks: '',
      useTeamAvgKm: false,
      kmByMonth: new Map(),
      perfByMonth: new Map(),
      onlineByMonth: new Map(),
      onlineMissingByMonth: new Set(),
      practicalByMonth: new Map(),
      faultByMonth: new Map(),
      incidentByMonth: new Map(),
      earliestYm: null,
    };
  }

  const [
    employeeRows,
    kmRows,
    kmSubsidyRows,
    perfRows,
    onlineRows,
    missingRows,
    practicalRows,
    faultRows,
    incidentRows,
  ] = await Promise.all([
    db.query(
      `SELECT hire_date, team, details FROM employees
        WHERE deleted_at IS NULL AND employee_id IN (${placeholders})
          AND (employment_status = '在职' OR employment_status IS NULL)
        LIMIT 1`,
      variants,
    ),
    db.query(
      `SELECT year, month, is_anomaly
         FROM kilometers_control_stats_monthly
        WHERE employee_id IN (${placeholders})`,
      variants,
    ),
    db.query(
      `SELECT year, month, MAX(COALESCE(has_subsidy, 0)) AS has_subsidy
         FROM kilometers_records
        WHERE employee_id IN (${placeholders})
        GROUP BY year, month`,
      variants,
    ).catch(() => []),
    db.query(
      `SELECT assessment_date, performance_points, twelve_point_deduction
         FROM performance_assessments
        WHERE deleted_at IS NULL AND employee_id IN (${placeholders})`,
      variants,
    ),
    db.query(
      `SELECT exam_year, exam_month, score, details
         FROM online_exams
        WHERE employee_id IN (${placeholders})`,
      variants,
    ),
    db.query(
      `SELECT missing_month
         FROM missing_exams
        WHERE employee_id IN (${placeholders})`,
      variants,
    ).catch(() => []),
    db.query(
      `SELECT exam_year, exam_month, score
         FROM practical_exams
        WHERE employee_id IN (${placeholders})`,
      variants,
    ),
    db.query(
      `SELECT fault_date, final_result, employee_ids
         FROM fault_disposals
        WHERE deleted_at IS NULL`,
    ),
    db.query(
      `SELECT event_date, operation_issues, employee_ids
         FROM incident_events
        WHERE deleted_at IS NULL`,
    ),
  ]);

  const hireYm = parseYm(employeeRows[0]?.hire_date);
  const team = String(employeeRows[0]?.team || '').trim();
  const remarks = extractRemarks(employeeRows[0]?.details);
  let earliestYm = hireYm;

  const subsidyByMonth = new Map();
  for (const row of kmSubsidyRows || []) {
    const year = Number(row.year);
    const month = Number(row.month);
    if (!Number.isFinite(year) || month < 1 || month > 12) continue;
    subsidyByMonth.set(ymKey(year, month), Number(row.has_subsidy) === 1);
  }

  // 公里「有数据」以 kilometers_records 为准；异常次数来自控制图。
  // 若控制图被算空/失败，不能把全员公里分打成 0。
  const kmByMonth = new Map();
  for (const row of kmSubsidyRows || []) {
    const year = Number(row.year);
    const month = Number(row.month);
    if (!Number.isFinite(year) || month < 1 || month > 12) continue;
    const key = ymKey(year, month);
    const bucket = pushBucket(kmByMonth, year, month, () => ({
      anomalyCount: 0,
      hasSubsidy: false,
    }));
    if (subsidyByMonth.get(key)) bucket.hasSubsidy = true;
    earliestYm = earlierYm(earliestYm, { year, month });
  }
  for (const row of kmRows || []) {
    const year = Number(row.year);
    const month = Number(row.month);
    if (!Number.isFinite(year) || month < 1 || month > 12) continue;
    const key = ymKey(year, month);
    const bucket = pushBucket(kmByMonth, year, month, () => ({
      anomalyCount: 0,
      hasSubsidy: Boolean(subsidyByMonth.get(key)),
    }));
    if (Number(row.is_anomaly) === 1) bucket.anomalyCount += 1;
    if (subsidyByMonth.get(key)) bucket.hasSubsidy = true;
    earliestYm = earlierYm(earliestYm, { year, month });
  }

  const perfByMonth = new Map();
  for (const row of perfRows || []) {
    // 绩效/嘉奖按业务月归桶：本月21日～下月20日 → 下月
    const ym = parseBusinessYm(row.assessment_date);
    if (!ym) continue;
    const bucket = pushBucket(perfByMonth, ym.year, ym.month, () => ({
      performanceDeduction: 0,
      drivingDeduction: 0,
    }));
    bucket.performanceDeduction += Number(row.performance_points) || 0;
    bucket.drivingDeduction += drivePointsValue(row.twelve_point_deduction);
    earliestYm = earlierYm(earliestYm, ym);
  }

  const onlineByMonth = new Map();
  const onlineMissingByMonth = new Set();
  for (const row of onlineRows || []) {
    const year = Number(row.exam_year);
    const month = Number(row.exam_month);
    if (!Number.isFinite(year) || month < 1 || month > 12) continue;
    let details = row.details;
    if (typeof details === 'string') {
      try { details = JSON.parse(details); } catch (_e) { details = {}; }
    }
    if (details && details.isMissingExam === true) {
      onlineMissingByMonth.add(ymKey(year, month));
      earliestYm = earlierYm(earliestYm, { year, month });
      continue;
    }
    if (!Number.isFinite(Number(row.score))) continue;
    const bucket = pushBucket(onlineByMonth, year, month, () => ({ scores: [] }));
    bucket.scores.push(Number(row.score));
    earliestYm = earlierYm(earliestYm, { year, month });
  }
  for (const row of missingRows || []) {
    const ym = parseYm(row.missing_month);
    if (!ym) continue;
    onlineMissingByMonth.add(ymKey(ym.year, ym.month));
    earliestYm = earlierYm(earliestYm, ym);
  }

  const practicalByMonth = new Map();
  for (const row of practicalRows || []) {
    const year = Number(row.exam_year);
    const month = Number(row.exam_month);
    if (!Number.isFinite(year) || month < 1 || month > 12) continue;
    if (!Number.isFinite(Number(row.score))) continue;
    const bucket = pushBucket(practicalByMonth, year, month, () => ({ scores: [] }));
    bucket.scores.push(Number(row.score));
    earliestYm = earlierYm(earliestYm, { year, month });
  }

  const faultByMonth = new Map();
  for (const row of faultRows || []) {
    const ids = parseEmployeeIds(row.employee_ids);
    if (!rowMatchesEmployee(ids, variants)) continue;
    const ym = parseCalendarYm(row.fault_date);
    if (!ym) continue;
    const bucket = pushBucket(faultByMonth, ym.year, ym.month, () => ({
      total: 0,
      success: 0,
    }));
    bucket.total += 1;
    if (isFaultSuccess(row.final_result)) bucket.success += 1;
    earliestYm = earlierYm(earliestYm, ym);
  }

  const incidentByMonth = new Map();
  for (const row of incidentRows || []) {
    const ids = parseEmployeeIds(row.employee_ids);
    if (!rowMatchesEmployee(ids, variants)) continue;
    const ym = parseCalendarYm(row.event_date);
    if (!ym) continue;
    const bucket = pushBucket(incidentByMonth, ym.year, ym.month, () => ({
      ok: 0,
      issue: 0,
    }));
    if (hasIncidentIssue(row.operation_issues)) bucket.issue += 1;
    else bucket.ok += 1;
    earliestYm = earlierYm(earliestYm, ym);
  }

  return {
    canonicalId,
    variants,
    hireYm,
    team,
    remarks,
    useTeamAvgKm: usesTeamAvgKm(remarks),
    kmByMonth,
    perfByMonth,
    onlineByMonth,
    onlineMissingByMonth,
    practicalByMonth,
    faultByMonth,
    incidentByMonth,
    earliestYm,
  };
}

function resolveMonthSpan(ctx, yearFilter = null) {
  const now = new Date();
  const end = { year: now.getFullYear(), month: now.getMonth() + 1 };
  let start = ctx.hireYm || ctx.earliestYm;
  if (!start) start = end;
  if (start && ymKey(start.year, start.month) > ymKey(end.year, end.month)) {
    start = end;
  }

  let months = monthRange(start, end);
  if (yearFilter != null && Number.isFinite(Number(yearFilter))) {
    const y = Number(yearFilter);
    months = months.filter((item) => item.year === y);
    if (!months.length) {
      for (let m = 1; m <= 12; m += 1) {
        if (ymKey(y, m) <= ymKey(end.year, end.month)) months.push({ year: y, month: m });
      }
    }
  }
  return months;
}

/** 该月是否有任一维度的实际导入数据（无数据月不落库、不参与排名） */
function monthHasSourceData(ctx, year, month) {
  const key = ymKey(year, month);
  return ctx.kmByMonth.has(key)
    || ctx.perfByMonth.has(key)
    || ctx.onlineByMonth.has(key)
    || ctx.practicalByMonth.has(key)
    || ctx.faultByMonth.has(key)
    || ctx.incidentByMonth.has(key);
}

function computeEmployeeMonth(ctx, year, month) {
  const key = ymKey(year, month);
  const km = ctx.kmByMonth.get(key);
  const perf = ctx.perfByMonth.get(key);
  const online = ctx.onlineByMonth.get(key);
  const practical = ctx.practicalByMonth.get(key);
  const fault = ctx.faultByMonth.get(key);
  const incident = ctx.incidentByMonth.get(key);

  const onlineScores = online?.scores || [];
  const practicalScores = practical?.scores || [];
  const hasMissingOnline = Boolean(ctx.onlineMissingByMonth?.has(key));

  const scores = computeMonthScores({
    hasKm: Boolean(km),
    kmAnomalyCount: km?.anomalyCount || 0,
    performanceDeduction: perf?.performanceDeduction || 0,
    drivingDeduction: perf?.drivingDeduction || 0,
    hasOnline: onlineScores.length > 0,
    hasMissingOnline,
    onlineAvg: onlineScores.length
      ? onlineScores.reduce((a, b) => a + b, 0) / onlineScores.length
      : 0,
    hasPractical: practicalScores.length > 0,
    practicalAvg: practicalScores.length
      ? practicalScores.reduce((a, b) => a + b, 0) / practicalScores.length
      : 0,
    faultTotalCount: fault?.total || 0,
    faultSuccessCount: fault?.success || 0,
    incidentOkCount: incident?.ok || 0,
    incidentIssueCount: incident?.issue || 0,
  });

  return {
    employeeId: ctx.canonicalId,
    year: Number(year),
    month: Number(month),
    ...scores,
  };
}

async function upsertMonthlyMetrics(metrics) {
  await db.execute(
    `INSERT INTO crew_metrics_employee_monthly
       (year, month, employee_id, km_score, km_anomaly_count,
        performance_score, performance_deduction, driving_deduction,
        online_exam, practical_exam, fault_score, fault_success_count,
        incident_score, incident_ok_count, incident_issue_count,
        total_score, formula_version, computed_at, version)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NOW(), 1)
     ON DUPLICATE KEY UPDATE
       km_score = VALUES(km_score),
       km_anomaly_count = VALUES(km_anomaly_count),
       performance_score = VALUES(performance_score),
       performance_deduction = VALUES(performance_deduction),
       driving_deduction = VALUES(driving_deduction),
       online_exam = VALUES(online_exam),
       practical_exam = VALUES(practical_exam),
       fault_score = VALUES(fault_score),
       fault_success_count = VALUES(fault_success_count),
       incident_score = VALUES(incident_score),
       incident_ok_count = VALUES(incident_ok_count),
       incident_issue_count = VALUES(incident_issue_count),
       total_score = VALUES(total_score),
       formula_version = VALUES(formula_version),
       computed_at = NOW(),
       version = version + 1`,
    [
      metrics.year,
      metrics.month,
      metrics.employeeId,
      metrics.kmScore,
      metrics.kmAnomalyCount,
      metrics.performanceScore,
      metrics.performanceDeduction,
      metrics.drivingDeduction,
      metrics.onlineExam,
      metrics.practicalExam,
      metrics.faultScore,
      metrics.faultSuccessCount,
      metrics.incidentScore,
      metrics.incidentOkCount,
      metrics.incidentIssueCount,
      metrics.totalScore,
      FORMULA_VERSION,
    ],
  );
}

/**
 * @param {string[]} employeeIds
 * @param {number[]|null} years 若传入则只重算这些年的月份；否则重算入职→当前全部月
 */
async function recomputeEmployeesYears(employeeIds = [], years = []) {
  await ensureSchema();
  const ids = [...new Set((employeeIds || []).map((id) => String(id || '').trim()).filter(Boolean))];
  const yearList = [...new Set((years || []).map(Number).filter((y) => Number.isFinite(y)))];
  let recomputed = 0;
  let changed = false;
  if (!ids.length) {
    return { recomputed, formulaVersion: FORMULA_VERSION };
  }

  // 组长 / 休假补贴公里保底需要同班组原始公里分，故一并加载队友
  const idPlaceholders = ids.map(() => '?').join(',');
  const seedRows = await db.query(
    `SELECT employee_id, team, details FROM employees
      WHERE deleted_at IS NULL
        AND (employment_status = '在职' OR employment_status IS NULL)
        AND employee_id IN (${idPlaceholders})`,
    ids,
  );
  const teamsNeeded = new Set();
  for (const row of seedRows || []) {
    if (usesTeamAvgKm(extractRemarks(row.details)) && row.team) {
      teamsNeeded.add(String(row.team).trim());
    }
  }
  const subsidyTeams = await db.query(
    `SELECT DISTINCT e.team
       FROM kilometers_records k
       INNER JOIN employees e
         ON e.employee_id = k.employee_id AND e.deleted_at IS NULL
      WHERE k.has_subsidy = 1
        AND k.employee_id IN (${idPlaceholders})
        AND e.team IS NOT NULL AND TRIM(e.team) != ''`,
    ids,
  ).catch(() => []);
  for (const row of subsidyTeams || []) {
    if (row.team) teamsNeeded.add(String(row.team).trim());
  }

  const computeIdSet = new Set(ids);
  if (teamsNeeded.size) {
    const teamList = [...teamsNeeded];
    const teamPlaceholders = teamList.map(() => '?').join(',');
    const teammates = await db.query(
      `SELECT employee_id FROM employees
        WHERE deleted_at IS NULL
          AND (employment_status = '在职' OR employment_status IS NULL)
          AND team IN (${teamPlaceholders})`,
      teamList,
    );
    for (const row of teammates || []) {
      if (row.employee_id) computeIdSet.add(String(row.employee_id).trim());
    }
  }

  const upsertKeys = new Set();
  for (const id of ids) {
    for (const variant of idVariants(id)) upsertKeys.add(variant);
  }

  /** @type {Array<{ metrics: object, hasKm: boolean, team: string, useTeamAvgKm: boolean, hasSubsidy: boolean, shouldUpsert: boolean }>} */
  const pending = [];

  for (const employeeId of computeIdSet) {
    const ctx = await loadEmployeeContext(employeeId);
    const shouldUpsert = ctx.variants.some((variant) => upsertKeys.has(variant))
      || upsertKeys.has(ctx.canonicalId);
    const months = yearList.length
      ? yearList.flatMap((year) => resolveMonthSpan(ctx, year))
      : resolveMonthSpan(ctx, null);
    const uniqueMonths = new Map();
    for (const item of months) uniqueMonths.set(ymKey(item.year, item.month), item);

    for (const { year, month } of uniqueMonths.values()) {
      if (!monthHasSourceData(ctx, year, month)) {
        if (shouldUpsert) {
          const del = await db.execute(
            `DELETE FROM crew_metrics_employee_monthly
              WHERE employee_id = ? AND year = ? AND month = ?`,
            [ctx.canonicalId, year, month],
          );
          if ((del?.affectedRows || 0) > 0) changed = true;
        }
        continue;
      }
      const metrics = computeEmployeeMonth(ctx, year, month);
      const kmBucket = ctx.kmByMonth.get(ymKey(year, month));
      pending.push({
        metrics,
        hasKm: Boolean(kmBucket),
        team: ctx.team || '',
        useTeamAvgKm: Boolean(ctx.useTeamAvgKm),
        hasSubsidy: Boolean(kmBucket?.hasSubsidy),
        shouldUpsert,
      });
    }
  }

  // 班组当月「有公里数据」人员的原始公里分均值
  const teamMonthScores = new Map();
  for (const item of pending) {
    if (!item.team || !item.hasKm) continue;
    const key = `${item.team}|${ymKey(item.metrics.year, item.metrics.month)}`;
    if (!teamMonthScores.has(key)) teamMonthScores.set(key, []);
    teamMonthScores.get(key).push(Number(item.metrics.kmScore) || 0);
  }
  const teamMonthAvg = new Map();
  for (const [key, scores] of teamMonthScores.entries()) {
    if (!scores.length) continue;
    teamMonthAvg.set(key, round1(scores.reduce((a, b) => a + b, 0) / scores.length));
  }

  for (const item of pending) {
    // 组长或休假补贴：低于班组均值则保底，高于则按实际
    if ((item.useTeamAvgKm || item.hasSubsidy) && item.team) {
      const avg = teamMonthAvg.get(`${item.team}|${ymKey(item.metrics.year, item.metrics.month)}`);
      if (avg != null && Number(item.metrics.kmScore) < avg) {
        item.metrics.kmScore = avg;
        item.metrics.totalScore = recalcTotalScore(item.metrics);
      }
    }
    if (!item.shouldUpsert) continue;
    await upsertMonthlyMetrics(item.metrics);
    recomputed += 1;
    changed = true;
  }

  if (changed) {
    await sync.bumpVersions(['crew_metrics_employee_monthly']);
  }
  return { recomputed, formulaVersion: FORMULA_VERSION };
}

/** 兼容旧调用：按人年对列表做重算 */
async function recomputePairs(pairs = []) {
  const byYear = new Map();
  for (const pair of pairs || []) {
    const employeeId = String(pair.employeeId || '').trim();
    const year = Number(pair.year);
    if (!employeeId || !Number.isFinite(year)) continue;
    if (!byYear.has(year)) byYear.set(year, new Set());
    byYear.get(year).add(employeeId);
  }
  let recomputed = 0;
  for (const [year, idSet] of byYear.entries()) {
    const report = await recomputeEmployeesYears([...idSet], [year]);
    recomputed += report.recomputed;
  }
  return { recomputed, formulaVersion: FORMULA_VERSION };
}

async function recomputeYear(year) {
  await ensureSchema();
  const employees = await db.query(
    `SELECT employee_id FROM employees
      WHERE deleted_at IS NULL AND (employment_status = '在职' OR employment_status IS NULL)`,
  );
  return recomputeEmployeesYears(
    employees.map((row) => row.employee_id),
    [Number(year)],
  );
}

async function recomputeAll() {
  await ensureSchema();
  const employees = await db.query(
    `SELECT employee_id FROM employees
      WHERE deleted_at IS NULL AND (employment_status = '在职' OR employment_status IS NULL)`,
  );
  return recomputeEmployeesYears(
    employees.map((row) => row.employee_id),
    [],
  );
}

/** 供前端/调试：单人累计平均（六维与总分） */
function averageMetrics(monthRows = []) {
  if (!monthRows.length) {
    return {
      kmScore: 0,
      performanceScore: BASE.performance,
      onlineExam: BASE.online,
      practicalExam: BASE.practical,
      faultScore: BASE.fault,
      incidentScore: BASE.incident,
      totalScore: round1(0 + BASE.performance + BASE.online + BASE.practical + BASE.fault + BASE.incident),
      monthCount: 0,
    };
  }
  const sum = monthRows.reduce((acc, row) => {
    const kmScore = Number(row.km_score ?? row.kmScore) || 0;
    const kmAnomaly = Number(row.km_anomaly_count ?? row.kmAnomalyCount) || 0;
    // 公里维：只平均「有公里数据」的月（无数据月 km=0 且 anomaly=0，不拉低）
    if (kmScore > 0 || kmAnomaly > 0) {
      acc.kmScore += kmScore;
      acc.kmMonths += 1;
    }
    acc.performanceScore += Number(row.performance_score ?? row.performanceScore) || 0;
    acc.onlineExam += Number(row.online_exam ?? row.onlineExam) || 0;
    acc.practicalExam += Number(row.practical_exam ?? row.practicalExam) || 0;
    acc.faultScore += Number(row.fault_score ?? row.faultScore) || 0;
    acc.incidentScore += Number(row.incident_score ?? row.incidentScore) || 0;
    acc.totalScore += Number(row.total_score ?? row.totalScore) || 0;
    return acc;
  }, {
    kmScore: 0,
    kmMonths: 0,
    performanceScore: 0,
    onlineExam: 0,
    practicalExam: 0,
    faultScore: 0,
    incidentScore: 0,
    totalScore: 0,
  });
  const n = monthRows.length;
  const kmScore = sum.kmMonths ? round1(sum.kmScore / sum.kmMonths) : 0;
  const performanceScore = round1(sum.performanceScore / n);
  const onlineExam = round1(sum.onlineExam / n);
  const practicalExam = round1(sum.practicalExam / n);
  const faultScore = round1(sum.faultScore / n);
  const incidentScore = round1(sum.incidentScore / n);
  // 画像分 = 各维累计平均之和（公里维已排除无公里月），避免「仅嘉奖月 km=0」拉低总分
  return {
    kmScore,
    performanceScore,
    onlineExam,
    practicalExam,
    faultScore,
    incidentScore,
    totalScore: round1(kmScore + performanceScore + onlineExam + practicalExam + faultScore + incidentScore),
    monthCount: n,
    kmMonthCount: sum.kmMonths,
  };
}

module.exports = {
  FORMULA_VERSION,
  BASE,
  ensureSchema,
  computeMonthScores,
  computeEmployeeMonth,
  averageMetrics,
  recomputePairs,
  recomputeEmployeesYears,
  recomputeYear,
  recomputeAll,
  idVariants,
  normalizeEmployeeId,
  padEmployeeId,
  ymKey,
  parseYm,
  usesTeamAvgKm,
  extractRemarks,
};