@primocaredentgroup/compensi-medici-core 0.1.0

package/convex/calculation/engine.ts

@@ -0,0 +1,598 @@
+/**
+ * Motore di calcolo compensi — funzioni pure.
+ *
+ * Formula estesa (dal Python create_commissions.py):
+ *   starting_price = amount (fisso) OPPURE (net_price - deduzione - lab_cost - lab_price)
+ *   calculated = starting_price * percentage * cpr_percentage * invisalign_perc
+ *
+ * Supporta: deduzioni configurabili, lab cost/price, Invisalign, rifacimenti, scope multipli.
+ */
+
+import type { Id } from "../_generated/dataModel";
+import type { RuleType, ExtendedProductionData, CommissionScope } from "../lib/types";
+import { resolveDeduction, type DeductionRuleConfig, type DeductionResult } from "./deductions";
+
+// ── Tipi input ───────────────────────────────────────────
+
+export interface ResolvedPlan {
+  _id: Id<"commissionPlans">;
+  userId: string;
+  code: string;
+  name: string;
+  status: string;
+  effectiveFrom: number;
+  effectiveTo?: number;
+}
+
+export interface ResolvedRule {
+  _id: Id<"commissionRules">;
+  planId: Id<"commissionPlans">;
+  name: string;
+  ruleType: RuleType;
+  priority: number;
+  isActive: boolean;
+  outputType: string;
+  explanationLabel: string;
+  conditions: Record<string, unknown>;
+  formula: Record<string, unknown>;
+  validFrom?: number;
+  validTo?: number;
+}
+
+export interface ProductionEntry {
+  _id: Id<"ledgerEntries">;
+  runId: Id<"compensationRuns">;
+  userId: string;
+  clinicId: string;
+  type: "production" | "storno";
+  sourceId?: string;
+  amount: number;
+  effectiveDate: number;
+  period: string;
+  metadata?: Record<string, unknown>;
+  extended?: ExtendedProductionData;
+}
+
+export interface InvisalignConfigEntry {
+  listRowId: string;
+  firstPhasePercentage: number;
+  otherPhasesPercentage: number;
+  firstPhaseMin: number;
+  otherPhasesMin: number;
+}
+
+export interface CalculationContext {
+  deductionRules: DeductionRuleConfig[];
+  invisalignConfig: InvisalignConfigEntry[];
+  invisalignMinUserIds: Set<string>;
+  globalSettings: Map<string, string>;
+}
+
+// ── Tipi output ──────────────────────────────────────────
+
+export interface CommissionEntryData {
+  runId: Id<"compensationRuns">;
+  userId: string;
+  clinicId: string;
+  type: "commission";
+  sourceType: "system";
+  sourceId: string;
+  planId: Id<"commissionPlans">;
+  ruleId: Id<"commissionRules">;
+  scope: CommissionScope;
+  companyId?: string;
+  description: string;
+  amount: number;
+  quantity: number;
+  unitAmount: number;
+  isManual: false;
+  effectiveDate: number;
+  period: string;
+  metadata: Record<string, unknown>;
+  createdBy: string;
+}
+
+export interface RuleApplicationData {
+  runId: Id<"compensationRuns">;
+  sourceLedgerEntryId: Id<"ledgerEntries">;
+  planId: Id<"commissionPlans">;
+  ruleId: Id<"commissionRules">;
+  matchedConditions: Record<string, unknown>;
+  formulaSnapshot: Record<string, unknown>;
+  formulaInput: Record<string, unknown>;
+  formulaOutput: Record<string, unknown>;
+  resultAmount: number;
+  explanationLabel: string;
+}
+
+export interface EngineResult {
+  entry: CommissionEntryData;
+  ruleApplication: RuleApplicationData;
+}
+
+export interface UnmatchedEntry {
+  entryId: Id<"ledgerEntries">;
+  userId: string;
+  clinicId: string;
+  amount: number;
+  reason: "no_active_plan" | "no_matching_rule";
+}
+
+export interface CalculationBatchResult {
+  results: EngineResult[];
+  unmatched: UnmatchedEntry[];
+  summary: {
+    totalProcessed: number;
+    totalMatched: number;
+    totalUnmatched: number;
+    totalCommissionAmount: number;
+  };
+}
+
+// ── 1. Risoluzione piano ─────────────────────────────────
+
+export function findActivePlan(
+  plans: ResolvedPlan[],
+  userId: string,
+  period: string,
+): ResolvedPlan | null {
+  const { periodStart, periodEnd } = parsePeriodBounds(period);
+
+  const matching = plans.filter((p) => {
+    if (p.userId !== userId) return false;
+    if (p.status !== "active") return false;
+    if (p.effectiveFrom > periodEnd) return false;
+    if (p.effectiveTo !== undefined && p.effectiveTo <= periodStart) return false;
+    return true;
+  });
+
+  if (matching.length === 0) return null;
+  if (matching.length > 1) {
+    throw new Error(
+      `Ambiguità: trovati ${matching.length} piani attivi per userId=${userId} ` +
+        `nel periodo ${period}: ${matching.map((p) => p.code).join(", ")}. ` +
+        `Risolvere disattivando i piani in eccesso.`,
+    );
+  }
+
+  return matching[0];
+}
+
+// ── 2. Matching condizioni ───────────────────────────────
+
+export function matchConditions(
+  entry: ProductionEntry,
+  conditions: Record<string, unknown>,
+): { matches: boolean; matchedFields: Record<string, unknown> } {
+  const matchedFields: Record<string, unknown> = {};
+  const ext = entry.extended;
+  const meta = entry.metadata ?? {};
+
+  const fieldMapping: Record<string, () => unknown> = {
+    clinicId: () => entry.clinicId,
+    category: () => meta.category ?? ext?.serviceCategoryName,
+    subcategory: () => meta.subcategory,
+    conventionId: () => meta.conventionId ?? ext?.conventionId,
+    sourceId: () => entry.sourceId ?? ext?.sourceId,
+    listId: () => ext?.listId,
+    serviceRegistryId: () => ext?.serviceRegistryId,
+    serviceRegistryGroupId: () => ext?.serviceRegistryGroupId,
+    listRowId: () => ext?.listRowId,
+    hasAgreement: () => ext?.conventionId !== undefined && ext?.conventionId !== null,
+    commissionProfileId: () => ext?.commissionProfileId,
+    serviceCategoryId: () => ext?.serviceCategoryId,
+  };
+
+  for (const [condKey, condValue] of Object.entries(conditions)) {
+    if (condValue === null || condValue === undefined || condValue === "*") {
+      matchedFields[condKey] = { condition: "*", value: "wildcard" };
+      continue;
+    }
+
+    const getEntryValue = fieldMapping[condKey];
+    if (!getEntryValue) {
+      return { matches: false, matchedFields: {} };
+    }
+
+    const entryValue = getEntryValue();
+
+    if (Array.isArray(condValue)) {
+      if (!condValue.includes(entryValue)) {
+        return { matches: false, matchedFields: {} };
+      }
+      matchedFields[condKey] = { condition: condValue, value: entryValue };
+    } else {
+      if (entryValue !== condValue) {
+        return { matches: false, matchedFields: {} };
+      }
+      matchedFields[condKey] = { condition: condValue, value: entryValue };
+    }
+  }
+
+  return { matches: true, matchedFields };
+}
+
+export function findMatchingRule(
+  entry: ProductionEntry,
+  rules: ResolvedRule[],
+  effectiveDate: number,
+): { rule: ResolvedRule; matchedFields: Record<string, unknown> } | null {
+  const activeRules = rules
+    .filter((r) => {
+      if (!r.isActive) return false;
+      if (r.validFrom !== undefined && r.validFrom > effectiveDate) return false;
+      if (r.validTo !== undefined && r.validTo <= effectiveDate) return false;
+      return true;
+    })
+    .sort((a, b) => a.priority - b.priority);
+
+  for (const rule of activeRules) {
+    const { matches, matchedFields } = matchConditions(
+      entry,
+      (rule.conditions ?? {}) as Record<string, unknown>,
+    );
+
+    if (matches) {
+      return { rule, matchedFields };
+    }
+  }
+
+  return null;
+}
+
+// ── 3. Formula estesa ────────────────────────────────────
+
+export interface FormulaResult {
+  amount: number;
+  input: Record<string, unknown>;
+  output: Record<string, unknown>;
+}
+
+/**
+ * Formula completa dal Python:
+ *
+ * Se la regola ha un amount fisso:
+ *   starting_price = amount * sign (negativo se net_price < 0 e amount presente)
+ *   calculated = starting_price * percentage * cpr_percentage
+ *
+ * Altrimenti:
+ *   starting_price = net_price - deduction - lab_cost - lab_price
+ *   calculated = starting_price * percentage * invisalign_perc
+ */
+export function evaluateExtendedFormula(
+  formula: Record<string, unknown>,
+  entry: ProductionEntry,
+  context: CalculationContext,
+): FormulaResult {
+  const formulaType = formula.type as string;
+  const ext = entry.extended;
+
+  if (!ext) {
+    return evaluateSimpleFormula(formula, entry.amount);
+  }
+
+  const ruleFixedAmount = formula.amount as number | undefined;
+  const rulePercentage = (formula.rate as number | undefined) ?? (ext.cprPercentage !== undefined ? ext.cprPercentage * 100 : undefined);
+
+  const deduction = resolveDeduction(ext, context.deductionRules, context.globalSettings, ruleFixedAmount);
+
+  const netPrice = ext.netPrice;
+  const listPrice = ext.listPrice;
+  const labCost = ext.labCost ?? 0;
+  const labPrice = ext.labPrice ?? 0;
+  const cprPercentage = ext.cprPercentage ?? 1;
+
+  const invisalignResult = resolveInvisalignPercentage(ext, context);
+
+  let startingPrice: number;
+  let percentage: number;
+
+  if (ruleFixedAmount !== undefined && ruleFixedAmount !== null) {
+    startingPrice = ruleFixedAmount;
+    if (netPrice < 0) startingPrice *= -1;
+    percentage = ((rulePercentage ?? 100) / 100) * (invisalignResult.percentage / 100);
+    const calculated = startingPrice * percentage * (ruleFixedAmount !== undefined ? cprPercentage : 1);
+    let finalCalculated = roundCurrency(calculated);
+
+    finalCalculated = applyRefactorLogic(ext, finalCalculated, listPrice);
+    finalCalculated = applySpecialCases(ext, finalCalculated, netPrice, listPrice, ruleFixedAmount);
+    finalCalculated = applyInvisalignMin(ext, finalCalculated, context, invisalignResult);
+
+    return {
+      amount: finalCalculated,
+      input: {
+        startingPrice, percentage: rulePercentage, cprPercentage, invisalignPerc: invisalignResult.percentage,
+        deduction: deduction.deductionAmount, labCost, labPrice, netPrice, listPrice,
+      },
+      output: {
+        calculatedAmount: finalCalculated,
+        deductionRule: deduction.ruleCode,
+        deductionExplanation: deduction.explanation,
+        invisalignApplied: invisalignResult.isInvisalign,
+        formula: `fisso ${ruleFixedAmount} × ${rulePercentage ?? 100}% × CPR ${cprPercentage} × Invisa ${invisalignResult.percentage}%`,
+      },
+    };
+  }
+
+  startingPrice = netPrice - deduction.deductionAmount - labCost - labPrice;
+  percentage = ((rulePercentage ?? 0) / 100) * (invisalignResult.percentage / 100);
+  const calculated = startingPrice * percentage;
+  let finalCalculated = roundCurrency(calculated);
+
+  finalCalculated = applyRefactorLogic(ext, finalCalculated, listPrice);
+  finalCalculated = applySpecialCases(ext, finalCalculated, netPrice, listPrice, ruleFixedAmount);
+  finalCalculated = applyInvisalignMin(ext, finalCalculated, context, invisalignResult);
+
+  return {
+    amount: finalCalculated,
+    input: {
+      startingPrice, percentage: rulePercentage, cprPercentage, invisalignPerc: invisalignResult.percentage,
+      deduction: deduction.deductionAmount, labCost, labPrice, netPrice, listPrice,
+    },
+    output: {
+      calculatedAmount: finalCalculated,
+      deductionRule: deduction.ruleCode,
+      deductionExplanation: deduction.explanation,
+      invisalignApplied: invisalignResult.isInvisalign,
+      formula: `(${netPrice} - ${deduction.deductionAmount} - ${labCost} - ${labPrice}) × ${rulePercentage ?? 0}% × Invisa ${invisalignResult.percentage}%`,
+    },
+  };
+}
+
+function evaluateSimpleFormula(
+  formula: Record<string, unknown>,
+  baseAmount: number,
+): FormulaResult {
+  const formulaType = formula.type as string;
+
+  switch (formulaType) {
+    case "percentage": {
+      const rate = formula.rate as number;
+      const amount = roundCurrency(baseAmount * (rate / 100));
+      return {
+        amount,
+        input: { baseAmount, rate },
+        output: { calculatedAmount: amount, formula: `${baseAmount} × ${rate}%` },
+      };
+    }
+    case "fixed_amount": {
+      const fixedAmount = formula.amount as number;
+      return {
+        amount: roundCurrency(fixedAmount),
+        input: { baseAmount, fixedAmount },
+        output: { calculatedAmount: roundCurrency(fixedAmount), formula: `fisso ${fixedAmount}` },
+      };
+    }
+    default:
+      throw new Error(`Tipo formula non supportato: "${formulaType}"`);
+  }
+}
+
+// ── Invisalign ───────────────────────────────────────────
+
+interface InvisalignResult {
+  isInvisalign: boolean;
+  percentage: number;
+  minAmount: number;
+}
+
+function resolveInvisalignPercentage(
+  ext: ExtendedProductionData,
+  context: CalculationContext,
+): InvisalignResult {
+  if (!ext.listRowId) return { isInvisalign: false, percentage: 100, minAmount: 0 };
+
+  const config = context.invisalignConfig.find((c) => c.listRowId === ext.listRowId);
+  if (!config) return { isInvisalign: false, percentage: 100, minAmount: 0 };
+
+  const percentage = ext.isFirstPhase ? config.firstPhasePercentage : config.otherPhasesPercentage;
+  const minAmount = ext.isFirstPhase ? config.firstPhaseMin : config.otherPhasesMin;
+
+  return { isInvisalign: true, percentage, minAmount };
+}
+
+function applyInvisalignMin(
+  ext: ExtendedProductionData,
+  calculated: number,
+  context: CalculationContext,
+  invisalignResult: InvisalignResult,
+): number {
+  if (!invisalignResult.isInvisalign) return calculated;
+  if (ext.scope !== "completed_rows") return calculated;
+  if (calculated === 0) return calculated;
+
+  const userId = ext.completedBy ?? "";
+  if (!context.invisalignMinUserIds.has(userId)) return calculated;
+
+  const sign = calculated < 0 ? -1 : 1;
+  return sign * Math.max(sign * calculated, invisalignResult.minAmount);
+}
+
+// ── Rifacimenti ──────────────────────────────────────────
+
+function applyRefactorLogic(
+  ext: ExtendedProductionData,
+  calculated: number,
+  listPrice: number,
+): number {
+  if (!ext.refactorRowId) return calculated;
+
+  if (ext.netPrice === 0 && ext.carePlanRowTypeId !== undefined && ext.carePlanRowTypeId !== 4) {
+    return 0;
+  }
+
+  if (listPrice < 0 || ext.carePlanRowTypeId === 1) {
+    const paidLastTime = ext.scope === "confirmed_care_plan"
+      ? ext.refactorCalculatedConfirmedCarePlan
+      : ext.refactorCalculated;
+
+    if (paidLastTime !== undefined && paidLastTime !== null && paidLastTime >= 0) {
+      return -paidLastTime;
+    }
+  }
+
+  return calculated;
+}
+
+// ── Casi speciali ────────────────────────────────────────
+
+function applySpecialCases(
+  ext: ExtendedProductionData,
+  calculated: number,
+  netPrice: number,
+  listPrice: number,
+  ruleFixedAmount: number | undefined,
+): number {
+  if (ext.carePlanTypeId === 4 && ruleFixedAmount !== undefined && netPrice === 0 && listPrice < 0) {
+    return calculated * -1;
+  }
+  return calculated;
+}
+
+// ── 4. Orchestrazione per singola entry ──────────────────
+
+export function calculateForEntry(
+  entry: ProductionEntry,
+  plans: ResolvedPlan[],
+  rulesByPlan: Map<string, ResolvedRule[]>,
+  createdBy: string,
+  context: CalculationContext,
+): EngineResult | UnmatchedEntry {
+  const plan = findActivePlan(plans, entry.userId, entry.period);
+  if (!plan) {
+    return {
+      entryId: entry._id,
+      userId: entry.userId,
+      clinicId: entry.clinicId,
+      amount: entry.amount,
+      reason: "no_active_plan",
+    };
+  }
+
+  const rules = rulesByPlan.get(plan._id) ?? [];
+  const matchResult = findMatchingRule(entry, rules, entry.effectiveDate);
+  if (!matchResult) {
+    return {
+      entryId: entry._id,
+      userId: entry.userId,
+      clinicId: entry.clinicId,
+      amount: entry.amount,
+      reason: "no_matching_rule",
+    };
+  }
+
+  const { rule, matchedFields } = matchResult;
+
+  const formulaResult = entry.extended
+    ? evaluateExtendedFormula(rule.formula as Record<string, unknown>, entry, context)
+    : evaluateSimpleFormula(rule.formula as Record<string, unknown>, entry.amount);
+
+  const scope: CommissionScope = entry.extended?.scope ?? "completed_rows";
+
+  const commissionEntry: CommissionEntryData = {
+    runId: entry.runId,
+    userId: entry.userId,
+    clinicId: entry.clinicId,
+    type: "commission",
+    sourceType: "system",
+    sourceId: entry._id,
+    planId: plan._id,
+    ruleId: rule._id,
+    scope,
+    companyId: entry.extended?.companyId,
+    description: `${rule.explanationLabel} (${entry.type}: ${entry.sourceId ?? entry._id})`,
+    amount: formulaResult.amount,
+    quantity: 1,
+    unitAmount: formulaResult.amount,
+    isManual: false as const,
+    effectiveDate: entry.effectiveDate,
+    period: entry.period,
+    metadata: {
+      sourceEntryType: entry.type,
+      sourceAmount: entry.amount,
+      planCode: plan.code,
+      ruleName: rule.name,
+      ruleType: rule.ruleType,
+      scope,
+    },
+    createdBy,
+  };
+
+  const ruleApplication: RuleApplicationData = {
+    runId: entry.runId,
+    sourceLedgerEntryId: entry._id,
+    planId: plan._id,
+    ruleId: rule._id,
+    matchedConditions: matchedFields,
+    formulaSnapshot: rule.formula as Record<string, unknown>,
+    formulaInput: formulaResult.input,
+    formulaOutput: formulaResult.output,
+    resultAmount: formulaResult.amount,
+    explanationLabel: rule.explanationLabel,
+  };
+
+  return { entry: commissionEntry, ruleApplication };
+}
+
+// ── 5. Calcolo batch ─────────────────────────────────────
+
+export function calculateBatch(
+  entries: ProductionEntry[],
+  plans: ResolvedPlan[],
+  rulesByPlan: Map<string, ResolvedRule[]>,
+  createdBy: string,
+  context?: CalculationContext,
+): CalculationBatchResult {
+  const ctx: CalculationContext = context ?? {
+    deductionRules: [],
+    invisalignConfig: [],
+    invisalignMinUserIds: new Set(),
+    globalSettings: new Map(),
+  };
+
+  const results: EngineResult[] = [];
+  const unmatched: UnmatchedEntry[] = [];
+  let totalCommissionAmount = 0;
+
+  for (const entry of entries) {
+    const result = calculateForEntry(entry, plans, rulesByPlan, createdBy, ctx);
+
+    if ("entry" in result) {
+      results.push(result);
+      totalCommissionAmount += result.entry.amount;
+    } else {
+      unmatched.push(result);
+    }
+  }
+
+  return {
+    results,
+    unmatched,
+    summary: {
+      totalProcessed: entries.length,
+      totalMatched: results.length,
+      totalUnmatched: unmatched.length,
+      totalCommissionAmount: roundCurrency(totalCommissionAmount),
+    },
+  };
+}
+
+// ── Helpers ──────────────────────────────────────────────
+
+export function parsePeriodBounds(period: string): {
+  periodStart: number;
+  periodEnd: number;
+} {
+  const [yearStr, monthStr] = period.split("-");
+  const year = parseInt(yearStr, 10);
+  const month = parseInt(monthStr, 10);
+
+  const periodStart = new Date(year, month - 1, 1).getTime();
+  const periodEnd = new Date(year, month, 0, 23, 59, 59, 999).getTime();
+
+  return { periodStart, periodEnd };
+}
+
+function roundCurrency(value: number): number {
+  return Math.round(value * 100) / 100;
+}