pleno-vue/tests/unit/invoice-distribution-calculations.spec.js

import { describe, expect, it } from 'vitest';
import {
  buildDistributionQueryState,
  getMonthRange,
  buildMonthSummary,
  buildDepartmentAllocations,
  buildDepartmentAllocationFooterTotals,
  buildCustomerAllocationRows,
  buildMonthComparison,
  buildSourceComposition,
  normalizeDistributionQueryState,
  normalizeCompareResult,
  aggregateCompareRows,
  sortCompareRows,
  sortMonthSummaries,
} from '@/views/dashboards/superUserDashboard/invoiceDistribution/imports/invoiceDistributionCalculations.js';

describe('invoice distribution calculations', () => {
  it('builds month ranges from first month to current month', () => {
    const result = getMonthRange(new Date('2026-01-10T00:00:00Z'), new Date('2026-03-20T00:00:00Z'), true);
    expect(result.map((item) => item.key)).toEqual(['2026-03', '2026-02', '2026-01']);
  });

  it('builds month summary with booked and source split', () => {
    const summary = buildMonthSummary({
      year: 2026,
      month: 2,
      periodData: {
        types: {
          all: [
            {
              transactions: [
                { amount: 100, booked: true, excluded: false },
                { amount: 25, booked: false, excluded: false },
                { amount: 30, booked: true, excluded: true },
              ],
            },
          ],
        },
      },
      fixedDistribution: {
        includes: {
          collective_fixed_pricing_results: {
            total_fixed_price: 40,
          },
        },
      },
      subscriptionDistribution: {
        includes: {
          collective_subscription_results: {
            total_subscription_price: 20,
          },
        },
      },
      customerPriceDistribution: {
        collective_results: {
          total_customer_price: 15,
        },
      },
    });

    expect(summary.bookedAmount).toBe(100);
    expect(summary.fixedPricingAmount).toBe(40);
    expect(summary.subscriptionAmount).toBe(20);
    expect(summary.customerPriceAmount).toBe(15);
    expect(summary.distributionAmount).toBe(60);
    expect(summary.otherBookedAmount).toBe(25);
    expect(summary.totalAmount).toBe(160);
  });

  it('prefers actually distributed fixed and subscription amounts for summary totals', () => {
    const summary = buildMonthSummary({
      year: 2026,
      month: 2,
      periodData: {
        types: {
          all: [
            {
              transactions: [
                { amount: 200, booked: true, excluded: false },
              ],
            },
          ],
        },
      },
      fixedDistribution: {
        collective_results: {
          total_fixed_price: 50,
          total_department_totals_relative_parsed: {
            Alpha: 30,
            Beta: 10,
          },
        },
      },
      subscriptionDistribution: {
        collective_results: {
          total_subscription_price: 120,
          subscription_price_department_distribution_parsed: {
            Alpha: 70,
            Beta: 20,
          },
        },
      },
      customerPriceDistribution: {
        collective_results: {
          total_customer_price: 15,
        },
      },
    });

    expect(summary.fixedPricingAmount).toBe(40);
    expect(summary.subscriptionAmount).toBe(90);
    expect(summary.customerPriceAmount).toBe(15);
    expect(summary.distributionAmount).toBe(130);
    expect(summary.totalAmount).toBe(330);
  });

  it('builds department allocations with percentages and booked estimate', () => {
    const rows = buildDepartmentAllocations({
      departments: [
        { id: 1, name: 'Alpha' },
        { id: 2, name: 'Beta' },
      ],
      bookedAmount: 300,
      fixedDistribution: {
        includes: {
          collective_fixed_pricing_results: {
            total_department_totals_relative_parsed: {
              Alpha: 60,
              Beta: 40,
            },
          },
        },
      },
      subscriptionDistribution: {
        includes: {
          collective_subscription_results: {
            subscription_price_department_distribution_parsed: {
              Alpha: 30,
            },
          },
        },
      },
      customerPriceDistribution: {
        collective_results: {
          customer_price_department_distribution_parsed: {
            Beta: 10,
          },
        },
      },
    });

    expect(rows).toHaveLength(2);
    expect(rows[0].departmentName).toBe('Alpha');
    expect(rows[0].totalAmount).toBe(90);
    expect(rows[0].sharePercent).toBe(69.23);
    expect(rows[0].estimatedBookedAllocation).toBe(207.69);
    expect(rows[1].departmentName).toBe('Beta');
    expect(rows[1].customerPriceAmount).toBe(10);
    expect(rows[1].totalAmount).toBe(40);
  });

  it('builds department footer totals without adding customer prices to the total column', () => {
    const totals = buildDepartmentAllocationFooterTotals([
      {
        fixedAmount: 120000,
        subscriptionAmount: 80000,
        customerPriceAmount: 15000,
        totalAmount: 215000,
      },
      {
        fixedAmount: 40000,
        subscriptionAmount: 57000,
        customerPriceAmount: 12000,
        totalAmount: 109000,
      },
    ]);

    expect(totals.fixedAmount).toBe(160000);
    expect(totals.subscriptionAmount).toBe(137000);
    expect(totals.customerPriceAmount).toBe(27000);
    expect(totals.totalAmount).toBe(297000);
  });

  it('builds customer rows and respects creation date filter', () => {
    const rows = buildCustomerAllocationRows({
      year: 2026,
      month: 2,
      departments: [{ id: 1, name: 'Alpha' }],
      fixedDistribution: {
        data: [
          {
            id: 1,
            customer_number: 10,
            customer_name: 'Customer A',
            meta: {
              fixed_pricing: {
                created_at: '2026-02-01T00:00:00Z',
                price: 100,
                original_price: 140,
                department_totals_relative: { 1: 100 },
              },
            },
          },
          {
            id: 2,
            customer_number: 20,
            customer_name: 'Future Customer',
            meta: {
              fixed_pricing: {
                created_at: '2026-03-01T00:00:00Z',
                price: 100,
                original_price: 140,
                department_totals_relative: { 1: 100 },
              },
            },
          },
        ],
      },
      subscriptionDistribution: {
        data: [],
      },
      customerPriceDistribution: {
        customers: [
          {
            id: 7,
            customer_number: 99,
            customer_name: 'Discount Customer',
            transactions: [{ id: 1, amount: 22, booked: true, excluded: false, date: '2026-02-05T00:00:00Z' }],
            meta: {
              customer_price: {
                created_at: '2026-02-05T00:00:00Z',
                price: 22,
                department_totals_relative: { 1: 22 },
              },
            },
          },
        ],
      },
    });

    expect(rows).toHaveLength(2);
    expect(rows[0].customerName).toBe('Customer A');
    expect(rows[0].departmentAllocations).toEqual({ Alpha: 100 });
    expect(rows[1].source).toBe('customer_prices');
  });

  it('builds month-over-month comparison deltas', () => {
    const comparison = buildMonthComparison(
      { totalAmount: 200, bookedAmount: 140, distributionAmount: 60 },
      { totalAmount: 100, bookedAmount: 120, distributionAmount: 30 }
    );

    expect(comparison.totalAmount.delta).toBe(100);
    expect(comparison.bookedAmount.delta).toBe(20);
    expect(comparison.distributionAmount.delta).toBe(30);
  });

  it('normalizes and serializes distribution query state', () => {
    const normalized = normalizeDistributionQueryState({
      compareMonth: '2026-02',
      compareMode: 'line_by_line',
      customerSearch: '  acme ',
      customerSource: 'customer_prices',
      customerDepartment: 'Ops',
      departmentSearch: ' nord ',
    });

    expect(normalized).toEqual({
      compareMonth: '2026-02',
      compareMode: 'line_by_line',
      compareVisibility: 'all',
      customerSearch: 'acme',
      customerSource: 'customer_prices',
      customerDepartment: 'Ops',
      departmentSearch: 'nord',
    });

    const serialized = buildDistributionQueryState(normalized);
    expect(serialized).toEqual({
      compareMonth: '2026-02',
      compareMode: 'line_by_line',
      customerSearch: 'acme',
      customerSource: 'customer_prices',
      customerDepartment: 'Ops',
      departmentSearch: 'nord',
    });
  });

  it('sorts month summaries and compare rows for decision-first tables', () => {
    const sortedMonths = sortMonthSummaries(
      [
        { key: '2026-01', year: 2026, month: 1, totalAmount: 10 },
        { key: '2026-03', year: 2026, month: 3, totalAmount: 40 },
        { key: '2026-02', year: 2026, month: 2, totalAmount: 20 },
      ],
      'month',
      'desc'
    );
    expect(sortedMonths.map((row) => row.key)).toEqual(['2026-03', '2026-02', '2026-01']);

    const sortedTotals = sortMonthSummaries(sortedMonths, 'total', 'asc');
    expect(sortedTotals.map((row) => row.totalAmount)).toEqual([10, 20, 40]);

    const sortedCompare = sortCompareRows([
      { invoiceId: 3, status: 'ok', warningCount: 0, difference: 0 },
      { invoiceId: 2, status: 'ok', warningCount: 2, difference: 4 },
      { invoiceId: 1, status: 'mismatch', warningCount: 1, difference: 10 },
    ]);
    expect(sortedCompare.map((row) => row.invoiceId)).toEqual([1, 2, 3]);
  });

  it('builds source composition percentages for KPI cues', () => {
    const composition = buildSourceComposition({
      fixedPricingAmount: 60,
      subscriptionAmount: 40,
      customerPriceAmount: 20,
      distributionAmount: 100,
    });
    expect(composition.fixedPercent).toBe(50);
    expect(composition.subscriptionPercent).toBe(33.33);
    expect(composition.customerPricePercent).toBe(16.67);
  });

  it('normalizes compare payloads for both modes and aggregates', () => {
    const okRow = normalizeCompareResult(
      { id: 1, customer_name: 'A', total_net_amount: 100 },
      {
        internal_total: 100,
        booked_total: 100,
        difference: 0,
        warnings: [],
        order_ids: [1, 2],
      },
      'invoice_total'
    );

    const mismatchRow = normalizeCompareResult(
      { id: 2, customer_name: 'B', total_net_amount: 100 },
      {
        internal_total: 100,
        booked_total: 90,
        difference: 10,
        warnings: ['Line mismatch'],
        order_ids: [3],
      },
      'line_by_line'
    );

    const v2Row = normalizeCompareResult(
      { id: 3, customer_name: 'C', total_net_amount: 200 },
      {
        collected_invoice_id: 3,
        warnings: ['Top-level warning'],
        details: {
          order_ids: [10, 20],
          internal: {
            normalized: {
              totals: {
                net_total: 200,
                billable_line_count: 2,
              },
            },
          },
          customer: {
            name: 'Customer V2',
          },
        },
        comparison: {
          totals: {
            internal_net_total: 200,
          },
          targets: {
            booked: {
              status: 'partial_mismatch',
              overall_match: false,
              totals: {
                target_net_total: 180,
              },
              mismatch_reasons: ['department_total_mismatch'],
              lines: {
                summary: {
                  mismatch_count: 1,
                  target_billable_count: 2,
                },
              },
            },
          },
          warnings: ['comparison warning'],
        },
      },
      'line_by_line'
    );

    expect(okRow.status).toBe('ok');
    expect(mismatchRow.status).toBe('mismatch');
    expect(mismatchRow.lineMismatchCount).toBe(1);
    expect(v2Row.status).toBe('mismatch');
    expect(v2Row.bookedTotal).toBe(180);
    expect(v2Row.difference).toBe(20);
    expect(v2Row.mismatchReasons).toContain('department_total_mismatch');
    expect(v2Row.lineMismatchCount).toBe(1);

    const aggregate = aggregateCompareRows([okRow, mismatchRow, v2Row]);
    expect(aggregate.total).toBe(3);
    expect(aggregate.mismatches).toBe(2);
    expect(aggregate.warningCount).toBe(4);
    expect(aggregate.totalDifference).toBe(30);
  });
});