public enum ExpenseCategory {
    // SA103 mapped categories
    COST_OF_SALES("Cost of goods bought for resale", "box_10", true,
        List.of("stock", "materials", "raw materials", "goods for resale")),

    CONSTRUCTION_COSTS("Construction industry subcontractor costs", "box_11", true,
        List.of("cis", "subcontractor", "construction")),

    WAGES_STAFF("Wages, salaries and other staff costs", "box_12", true,
        List.of("wages", "salary", "pension", "employee", "staff")),

    CAR_VAN_TRAVEL("Car, van and travel expenses", "box_13", true,
        List.of("fuel", "petrol", "diesel", "mileage", "train", "bus", "parking", "toll")),

    RENT_RATES_POWER("Rent, rates, power and insurance costs", "box_14", true,
        List.of("rent", "rates", "electricity", "gas", "water", "insurance", "council tax")),

    REPAIRS_MAINTENANCE("Repairs and maintenance", "box_15", true,
        List.of("repairs", "maintenance", "servicing")),

    PHONE_OFFICE("Phone, fax, stationery and office costs", "box_16", true,
        List.of("phone", "mobile", "internet", "broadband", "stationery", "printer")),

    ADVERTISING("Advertising and business entertainment", "box_17", true,
        List.of("advertising", "marketing", "website", "domain", "hosting", "seo")),

    INTEREST_FINANCE("Interest on bank and other loans", "box_18", true,
        List.of("loan interest", "mortgage interest", "finance charges")),

    BANK_CHARGES("Bank, credit card and financial charges", "box_19", true,
        List.of("bank charges", "transaction fees", "payment processing")),

    IRRECOVERABLE_DEBTS("Irrecoverable debts written off", "box_20", true,
        List.of("bad debt", "written off")),

    ACCOUNTANCY_LEGAL("Accountancy, legal and professional fees", "box_21", true,
        List.of("accountant", "legal", "solicitor", "consultant", "professional")),

    DEPRECIATION("Depreciation", "box_22", false, // NOT allowable
        List.of("depreciation")),

    OTHER_EXPENSES("Other business expenses", "box_23", true,
        List.of("subscriptions", "memberships", "training", "books"));

    private final String description;
    private final String sa103Box;
    private final boolean taxDeductible;
    private final List<String> keywords;

    /**
     * Suggest category based on expense description.
     */
    public static Optional<ExpenseCategory> suggestCategory(String description) {
        String lower = description.toLowerCase();
        return Arrays.stream(values())
            .filter(cat -> cat.keywords.stream().anyMatch(lower::contains))
            .findFirst();
    }
}

public class TaxRates2025_26 implements TaxRates {

    // Personal Allowance
    public static final Money PERSONAL_ALLOWANCE = Money.of(12_570);
    public static final Money PA_TAPER_THRESHOLD = Money.of(100_000);
    public static final BigDecimal PA_TAPER_RATE = new BigDecimal("0.50");

    // Income Tax Bands
    public static final TaxBand BASIC_RATE = TaxBand.of(
        Money.ZERO, Money.of(37_700), new BigDecimal("0.20")
    );
    public static final TaxBand HIGHER_RATE = TaxBand.of(
        Money.of(37_700), Money.of(125_140), new BigDecimal("0.40")
    );
    public static final TaxBand ADDITIONAL_RATE = TaxBand.of(
        Money.of(125_140), Money.UNLIMITED, new BigDecimal("0.45")
    );

    // National Insurance Class 4
    public static final Money NI_LOWER_PROFITS_LIMIT = Money.of(12_570);
    public static final Money NI_UPPER_PROFITS_LIMIT = Money.of(50_270);
    public static final BigDecimal NI_MAIN_RATE = new BigDecimal("0.06"); // 6%
    public static final BigDecimal NI_ADDITIONAL_RATE = new BigDecimal("0.02"); // 2%

    // National Insurance Class 2 (voluntary from April 2024)
    public static final Money NI_CLASS_2_SMALL_PROFITS_THRESHOLD = Money.of(6_845);
    public static final Money NI_CLASS_2_WEEKLY = Money.of(3.50); // Updated for 2025/26
}

@ApplicationScoped
public class SelfEmploymentTaxCalculator {

    @Inject
    TaxRatesProvider taxRatesProvider;

    public TaxCalculation calculate(TaxableIncome income, TaxYear taxYear) {
        TaxRates rates = taxRatesProvider.getRatesForYear(taxYear);

        // Calculate Personal Allowance (with taper if over £100k)
        Money personalAllowance = calculatePersonalAllowance(
            income.totalIncome(), rates
        );

        // Calculate taxable income after Personal Allowance
        Money taxableIncome = income.totalIncome()
            .subtract(personalAllowance)
            .max(Money.ZERO);

        // Calculate Income Tax
        TaxBreakdown incomeTax = calculateIncomeTax(taxableIncome, rates);

        // Calculate National Insurance Class 4
        TaxBreakdown niClass4 = calculateNIClass4(income.selfEmploymentProfit(), rates);

        // Calculate National Insurance Class 2
        Money niClass2 = calculateNIClass2(income.selfEmploymentProfit(), rates);

        return TaxCalculation.builder()
            .taxYear(taxYear)
            .totalIncome(income.totalIncome())
            .personalAllowance(personalAllowance)
            .taxableIncome(taxableIncome)
            .incomeTax(incomeTax)
            .niClass4(niClass4)
            .niClass2(niClass2)
            .totalTaxDue(incomeTax.total().add(niClass4.total()).add(niClass2))
            .build();
    }

    private Money calculatePersonalAllowance(Money totalIncome, TaxRates rates) {
        if (totalIncome.isLessThanOrEqual(rates.paTaperThreshold())) {
            return rates.personalAllowance();
        }

        // Reduce PA by £1 for every £2 over £100,000
        Money excess = totalIncome.subtract(rates.paTaperThreshold());
        Money reduction = excess.multiply(rates.paTaperRate());
        Money reducedPA = rates.personalAllowance().subtract(reduction);

        return reducedPA.max(Money.ZERO);
    }

    private TaxBreakdown calculateIncomeTax(Money taxableIncome, TaxRates rates) {
        List<TaxBandResult> bands = new ArrayList<>();
        Money remaining = taxableIncome;

        for (TaxBand band : rates.incomeTaxBands()) {
            if (remaining.isZero()) break;

            Money bandWidth = band.upperLimit().subtract(band.lowerLimit());
            Money taxableInBand = remaining.min(bandWidth);
            Money taxInBand = taxableInBand.multiply(band.rate());

            bands.add(new TaxBandResult(band.name(), taxableInBand, band.rate(), taxInBand));
            remaining = remaining.subtract(taxableInBand);
        }

        Money total = bands.stream()
            .map(TaxBandResult::tax)
            .reduce(Money.ZERO, Money::add);

        return new TaxBreakdown(bands, total);
    }

    private TaxBreakdown calculateNIClass4(Money profit, TaxRates rates) {
        List<TaxBandResult> bands = new ArrayList<>();

        // Main rate: 6% on profits between £12,570 and £50,270
        if (profit.isGreaterThan(rates.niLowerProfitsLimit())) {
            Money mainBandProfit = profit
                .min(rates.niUpperProfitsLimit())
                .subtract(rates.niLowerProfitsLimit())
                .max(Money.ZERO);

            Money mainRateTax = mainBandProfit.multiply(rates.niMainRate());
            bands.add(new TaxBandResult("Main Rate (6%)", mainBandProfit,
                rates.niMainRate(), mainRateTax));
        }

        // Additional rate: 2% on profits over £50,270
        if (profit.isGreaterThan(rates.niUpperProfitsLimit())) {
            Money additionalProfit = profit.subtract(rates.niUpperProfitsLimit());
            Money additionalTax = additionalProfit.multiply(rates.niAdditionalRate());
            bands.add(new TaxBandResult("Additional Rate (2%)", additionalProfit,
                rates.niAdditionalRate(), additionalTax));
        }

        Money total = bands.stream()
            .map(TaxBandResult::tax)
            .reduce(Money.ZERO, Money::add);

        return new TaxBreakdown(bands, total);
    }

    private Money calculateNIClass2(Money profit, TaxRates rates) {
        // Class 2 NI: £3.45/week if profit > £12,570
        if (profit.isGreaterThan(rates.niClass2Threshold())) {
            return rates.niClass2Weekly().multiply(52);
        }
        return Money.ZERO;
    }
}

public class SimplifiedExpenses {

    // Working from home (hours/month)
    public static final Map<Integer, Money> HOME_OFFICE_RATES = Map.of(
        25, Money.of(10),  // 25-50 hours: £10/month
        51, Money.of(18),  // 51-100 hours: £18/month
        101, Money.of(26)  // 101+ hours: £26/month
    );

    // HMRC Approved Mileage Rates (2025/26 - unchanged)
    public static final Money CAR_MILEAGE_FIRST_10000 = Money.of(0.45);
    public static final Money CAR_MILEAGE_AFTER_10000 = Money.of(0.25);
    public static final Money MOTORCYCLE_MILEAGE = Money.of(0.24);
    public static final Money BICYCLE_MILEAGE = Money.of(0.20);

    /**
     * Calculate simplified home office deduction.
     */
    public Money calculateHomeOffice(int hoursPerMonth, int months) {
        Money monthlyRate = HOME_OFFICE_RATES.entrySet().stream()
            .filter(e -> hoursPerMonth >= e.getKey())
            .max(Map.Entry.comparingByKey())
            .map(Map.Entry::getValue)
            .orElse(Money.ZERO);

        return monthlyRate.multiply(months);
    }

    /**
     * Calculate mileage deduction using HMRC approved rates.
     */
    public Money calculateMileage(int businessMiles, VehicleType type) {
        return switch (type) {
            case CAR, VAN -> {
                int first10k = Math.min(businessMiles, 10_000);
                int after10k = Math.max(businessMiles - 10_000, 0);
                yield CAR_MILEAGE_FIRST_10000.multiply(first10k)
                    .add(CAR_MILEAGE_AFTER_10000.multiply(after10k));
            }
            case MOTORCYCLE -> MOTORCYCLE_MILEAGE.multiply(businessMiles);
            case BICYCLE -> BICYCLE_MILEAGE.multiply(businessMiles);
        };
    }
}

public record QuarterlyPeriod(
    int quarter,
    LocalDate start,
    LocalDate end,
    LocalDate deadline
) {
    public static List<QuarterlyPeriod> forTaxYear(TaxYear year) {
        int startYear = year.startYear();
        return List.of(
            new QuarterlyPeriod(1,
                LocalDate.of(startYear, 4, 6),
                LocalDate.of(startYear, 7, 5),
                LocalDate.of(startYear, 8, 5)),
            new QuarterlyPeriod(2,
                LocalDate.of(startYear, 7, 6),
                LocalDate.of(startYear, 10, 5),
                LocalDate.of(startYear, 11, 5)),
            new QuarterlyPeriod(3,
                LocalDate.of(startYear, 10, 6),
                LocalDate.of(startYear + 1, 1, 5),
                LocalDate.of(startYear + 1, 2, 5)),
            new QuarterlyPeriod(4,
                LocalDate.of(startYear + 1, 1, 6),
                LocalDate.of(startYear + 1, 4, 5),
                LocalDate.of(startYear + 1, 5, 5))
        );
    }
}