Walk into any auditwith nothing to hide.

// Litres of Absolute Alcohol
function calculateLAL(volumeLitres: number, abv: number): number {
  return volumeLitres * (abv / 100);
}

// Beer has a 1.15% ABV offset per ATO rules
function calculateBeerLAL(volumeLitres: number, abv: number): number {
  return volumeLitres * ((abv - 1.15) / 100);
}

// OIML R-22 polynomial coefficients for temperature correction
// Reference temperature: 20°C (Australian standard)
const TEMPERATURE_COMPENSATION_FACTOR = 0.00036; // per °C

function adjustVolumeForTemperature(
  volumeLitres: number,
  tempCelsius: number
): number {
  const tempDiff = tempCelsius - 20;
  const volumeAdjustmentFactor = 1 + (tempDiff * TEMPERATURE_COMPENSATION_FACTOR);
  return volumeLitres / volumeAdjustmentFactor;
}

// ATO requires truncation to 1 decimal place
// 40.19 → 40.1 (NOT 40.2)
// 40.95 → 40.9 (NOT 41.0)
export function truncateToOneDecimal(value: number): number {
  return Math.trunc(value * 10) / 10;
}

// Critical: Sum precise values FIRST, then truncate
function aggregateLALsForATO(lalValues: number[]): number {
  const preciseSum = lalValues.reduce((a, b) => a + b, 0);
  return truncateToOneDecimal(preciseSum);
}

// Duty = LALs × Current ATO Rate
// Remission applied up to $350k/year cap
function calculateDuty(
  lals: number,
  ratePerLAL: number,
  remissionBalance: number
): DutyResult {
  const grossDuty = lals * ratePerLAL;
  const remissionApplied = Math.min(grossDuty, remissionBalance);
  const netDuty = grossDuty - remissionApplied;

  return { grossDuty, remissionApplied, netDuty };
}

// When water is added to ethanol, volume SHRINKS
// Peak contraction ~4.5% at 50-55% ABV (molecular packing)
// Source: OIML R-22 / TTB Table 4

const CONTRACTION_FACTORS: Record<number, number> = {
  0: 0.0,    20: 0.03,   40: 0.044,
  50: 0.0455, // Peak contraction
  60: 0.043,  80: 0.022,  100: 0.0,
};

// Linear interpolation for any ABV
export function getContractionFactor(abv: number): number {
  const lowerAbv = Math.floor(abv / 5) * 5;
  const upperAbv = lowerAbv + 5;
  const fraction = (abv - lowerAbv) / 5;
  return CONTRACTION_FACTORS[lowerAbv] +
    (CONTRACTION_FACTORS[upperAbv] - CONTRACTION_FACTORS[lowerAbv]) * fraction;
}

// Annual cap resets July 1 (Australian financial year)
export const REMISSION_ANNUAL_CAP = 350000;
const FINANCIAL_YEAR_START_MONTH = 6; // July (0-indexed)

export function getCurrentFinancialYear(date = new Date()): string {
  const month = date.getMonth();
  const year = date.getFullYear();
  const fyStartYear = month < FINANCIAL_YEAR_START_MONTH ? year - 1 : year;
  return `${fyStartYear}-${fyStartYear + 1}`;
}

export function calculateRemissionBalance(
  transactions: { date: Date; amount: number }[]
): { remaining: number; utilizationPercent: number } {
  const usedToDate = transactions.reduce((sum, t) => sum + t.amount, 0);
  return {
    remaining: Math.max(0, REMISSION_ANNUAL_CAP - usedToDate),
    utilizationPercent: (usedToDate / REMISSION_ANNUAL_CAP) * 100,
  };
}

// Problem: Final ABV depends on volume, which depends on
// contraction, which depends on final ABV. We iterate.

export function calculateDilutionWithContraction(input: DilutionInput) {
  const inputLals = volume * (abv / 100); // LALs preserved
  let waterToAdd = naiveEstimate;

  for (let i = 0; i < 20; i++) {  // Newton-Raphson style
    const theoreticalVolume = volume + waterToAdd;
    const estimatedAbv = (inputLals / theoreticalVolume) * 100;
    const contraction = getContractionFactor(estimatedAbv);
    const actualVolume = theoreticalVolume * (1 - contraction);
    const achievedAbv = (inputLals / actualVolume) * 100;

    if (Math.abs(achievedAbv - targetAbv) < 0.005) break;
    waterToAdd += (achievedAbv - targetAbv) * actualVolume / achievedAbv;
  }
  return { waterToAddLiters: waterToAdd, iterations: i };
}

// Blended ABV = (Sum of LALs) / (Total Volume) × 100
function calculateBlendedAbv(components) {
  const totalLals = components.reduce(
    (sum, c) => sum + c.volumeLiters * (c.abvPercent / 100), 0
  );
  const totalVolume = components.reduce(
    (sum, c) => sum + c.volumeLiters, 0
  );
  return totalVolume > 0 ? (totalLals / totalVolume) * 100 : 0;
}

// International proof systems
const usProof = abv * 2;           // US: ABV × 2
const ukProofSikes = abv * 1.75;   // UK: ABV × 1.75

// OIML R-22 specific gravity polynomial (at 20°C)
const sg = 0.99823 - 0.11977*x - 0.07965*x² + 0.01017*x³;

// Mass percent from density (ethanol: 0.78934, water: 0.99823)
const massPercent = (ethanolMass / totalMass) * 100;

// LAL Efficiency = (output LALs / input LALs) × 100
const washLals = washVolume * (washAbv / 100);
const spiritLals = spiritVolume * (spiritAbv / 100);
const efficiency = (spiritLals / washLals) * 100;

// Rating thresholds:
// ≥95% = excellent | ≥90% = good | ≥80% = average | <80% = poor