#!/usr/bin/env python3
"""Amortisation d'un prêt immobilier français : mensualité, échéancier, coût, TAEG.

Sert à produire les valeurs de référence des known-answer tests de `immo-core`.
Toute l'arithmétique est en `Decimal` (jamais de `float`) et arrondie au centime
avec ROUND_HALF_UP, comme les tableaux d'amortissement bancaires.

Conventions retenues, vérifiées contre un tableau d'amortissement réel
(Caisse d'Épargne, 2020, cf. `verify`) :

- Taux mensuel **proportionnel** : `taux_nominal_annuel / 12`. C'est ce
  qu'imprime l'offre ("TAUX : 1,1500 % PROPORTIONNEL"), et non un taux
  équivalent actuariel `(1+t)^(1/12)-1`.
- Mensualité constante : `C * i / (1 - (1+i)^-n)`, arrondie au centime.
- Ligne d'échéance : `intérêts = arrondi(CRD * i)`, `capital = mensualité -
  intérêts`. La dernière échéance est ajustée pour solder exactement le CRD.
- Durée totale = durée du différé + durée d'amortissement (l'offre de référence
  annonce 300 mois pour 3 mois de différé + 297 échéances).

Recoupement avec le simulateur de l'ANIL (vérifié le 2026-08-03,
https://www.anil.org/outils/outils-de-calcul/echeancier-dun-pret/) : mensualité,
TAEG et première ligne d'échéance sont identiques au centime. Les totaux
diffèrent de 0,14 à 0,36 EUR parce que l'ANIL somme la mensualité **non
arrondie** (240 x 863,0184980... = 207 124,44) là où l'emprunteur paie
réellement 240 x 863,02. C'est le tableau bancaire qui tranche : il arrondit
chaque ligne, et c'est cette convention-là qui reproduit ses 297 échéances.
L'ANIL refuse un taux nul et un capital décimal : le PTZ et la base capitalisée
exacte n'y sont pas testables.

TAEG : taux actuariel annuel qui annule la valeur actualisée des flux, périodes
exprimées en années (art. R. 314-3 du code de la consommation). Avec des
échéances mensuelles régulières il résout
`capital_net = somme(échéance_k / (1 + TAEG)^(k/12))`.
Le capital net est diminué des frais payés au déblocage (frais de dossier,
garantie), qui font donc monter le TAEG au-dessus du taux nominal.
L'assurance emprunteur n'est pas modélisée ici : à ajouter aux flux quand on
voudra un TAEG assurance comprise.
"""

from __future__ import annotations

import argparse
import json
import re
import subprocess
import sys
from dataclasses import dataclass, field
from decimal import Decimal, getcontext, ROUND_HALF_UP

# Marge confortable pour les puissances et la recherche de racine du TAEG.
getcontext().prec = 40

CENT = Decimal("0.01")
MONTHS_PER_YEAR = Decimal(12)


def to_cents(value: Decimal) -> Decimal:
    """Arrondit au centime, ROUND_HALF_UP (convention bancaire française)."""
    return value.quantize(CENT, rounding=ROUND_HALF_UP)


class DeferralKind:
    """Traitement des intérêts pendant le différé.

    NONE     : pas de différé.
    TOTAL    : rien n'est payé, les intérêts sont capitalisés dans le CRD.
    PARTIAL  : seuls les intérêts sont payés (intérêts intercalaires), le
               capital reste inchangé.
    """

    NONE = "none"
    TOTAL = "total"
    PARTIAL = "partial"

    ALL = (NONE, TOTAL, PARTIAL)


@dataclass(frozen=True)
class Installment:
    rank: int
    phase: str  # "differe" ou "amortissement"
    payment: Decimal
    principal: Decimal
    interest: Decimal
    capitalised_interest: Decimal
    remaining_capital: Decimal

    def as_dict(self) -> dict:
        return {
            "rank": self.rank,
            "phase": self.phase,
            "payment": str(self.payment),
            "principal": str(self.principal),
            "interest": str(self.interest),
            "capitalised_interest": str(self.capitalised_interest),
            "remaining_capital": str(self.remaining_capital),
        }


@dataclass
class LoanOffer:
    """Une offre de prêt à mensualités constantes."""

    id: str  # identifiant stable, sert de nom de fonction Rust
    label: str
    borrowed_capital: Decimal
    annual_nominal_rate: Decimal  # 0.0341 pour 3,41 %
    total_duration_in_months: int
    deferral_in_months: int = 0
    deferral_kind: str = DeferralKind.NONE
    upfront_fees: Decimal = field(default_factory=lambda: Decimal(0))

    def __post_init__(self) -> None:
        if self.borrowed_capital <= 0:
            raise ValueError(f"{self.label}: capital emprunté non strictement positif")
        if self.annual_nominal_rate < 0:
            raise ValueError(f"{self.label}: taux nominal négatif")
        if self.total_duration_in_months <= 0:
            raise ValueError(f"{self.label}: durée totale nulle")
        if self.deferral_kind not in DeferralKind.ALL:
            raise ValueError(f"{self.label}: différé inconnu {self.deferral_kind!r}")
        if self.deferral_in_months < 0:
            raise ValueError(f"{self.label}: différé négatif")
        if self.deferral_in_months >= self.total_duration_in_months:
            raise ValueError(f"{self.label}: le différé absorbe toute la durée")
        if self.deferral_in_months == 0 and self.deferral_kind != DeferralKind.NONE:
            raise ValueError(f"{self.label}: différé de 0 mois mais de type non nul")
        if self.deferral_in_months > 0 and self.deferral_kind == DeferralKind.NONE:
            raise ValueError(f"{self.label}: différé non nul sans type de différé")

    @property
    def monthly_rate(self) -> Decimal:
        """Taux mensuel proportionnel. Non arrondi : c'est un taux, pas un montant."""
        return self.annual_nominal_rate / MONTHS_PER_YEAR

    @property
    def amortisation_in_months(self) -> int:
        return self.total_duration_in_months - self.deferral_in_months

    @property
    def amortised_capital(self) -> Decimal:
        """Capital sur lequel court l'amortissement, après capitalisation du différé."""
        if self.deferral_kind != DeferralKind.TOTAL:
            return self.borrowed_capital
        capital = self.borrowed_capital
        for _ in range(self.deferral_in_months):
            capital = to_cents(capital + to_cents(capital * self.monthly_rate))
        return capital

    @property
    def monthly_repayment(self) -> Decimal:
        """Mensualité constante de la phase d'amortissement, arrondie au centime."""
        capital = self.amortised_capital
        n = self.amortisation_in_months
        i = self.monthly_rate
        if i == 0:
            # Prêt à taux zéro : la mensualité est un simple prorata du capital.
            return to_cents(capital / Decimal(n))
        discount = (Decimal(1) + i) ** -n
        return to_cents(capital * i / (Decimal(1) - discount))

    def schedule(self) -> list[Installment]:
        """Échéancier complet, différé inclus, dernière échéance ajustée."""
        rows: list[Installment] = []
        capital = self.borrowed_capital
        rank = 0

        for _ in range(self.deferral_in_months):
            rank += 1
            interest = to_cents(capital * self.monthly_rate)
            if self.deferral_kind == DeferralKind.TOTAL:
                capital = to_cents(capital + interest)
                rows.append(
                    Installment(rank, "differe", Decimal("0.00"), Decimal("0.00"),
                                Decimal("0.00"), interest, capital)
                )
            else:  # PARTIAL : les intérêts sont payés, le capital ne bouge pas.
                rows.append(
                    Installment(rank, "differe", interest, Decimal("0.00"),
                                interest, Decimal("0.00"), capital)
                )

        payment = self.monthly_repayment
        n = self.amortisation_in_months
        for k in range(1, n + 1):
            rank += 1
            interest = to_cents(capital * self.monthly_rate)
            if k == n:
                # Dernière échéance : elle solde le capital restant. La banque
                # garde la mensualité constante et laisse la colonne intérêts
                # absorber la dérive d'arrondi accumulée (offre de référence :
                # 1 908,59 de capital + 0,41 d'intérêts = 1 909,00, au lieu de
                # 1,83 d'intérêts stricts). Si la dérive va dans l'autre sens,
                # la mensualité ne suffit pas et l'échéance est relevée.
                principal = capital
                # L'échéance reste bornée par le capital restant (plancher) et
                # par capital + intérêts stricts (plafond) : sur un PTZ, où les
                # intérêts stricts sont nuls, elle se réduit donc au capital et
                # la dérive d'arrondi ne peut pas se déguiser en intérêts.
                due = min(max(payment, capital), to_cents(capital + interest))
                interest = to_cents(due - principal)
            else:
                due = payment
                principal = to_cents(due - interest)
            capital = to_cents(capital - principal)
            rows.append(
                Installment(rank, "amortissement", due, principal, interest,
                            Decimal("0.00"), capital)
            )

        if capital != 0:
            raise AssertionError(f"{self.label}: capital non soldé ({capital})")
        return rows

    def total_interest(self, rows: list[Installment] | None = None) -> Decimal:
        """Intérêts effectivement payés + intérêts capitalisés pendant le différé."""
        rows = rows if rows is not None else self.schedule()
        return sum(
            (r.interest + r.capitalised_interest for r in rows), Decimal(0)
        )

    def total_credit_cost(self, rows: list[Installment] | None = None) -> Decimal:
        """Coût complet du crédit = intérêts + frais initiaux (hors assurance)."""
        return self.total_interest(rows) + self.upfront_fees

    def total_paid(self, rows: list[Installment] | None = None) -> Decimal:
        rows = rows if rows is not None else self.schedule()
        return sum((r.payment for r in rows), Decimal(0)) + self.upfront_fees

    def taeg(self, rows: list[Installment] | None = None) -> Decimal:
        """TAEG actuariel annuel, frais initiaux inclus, assurance exclue."""
        rows = rows if rows is not None else self.schedule()
        flows = [(Decimal(r.rank) / MONTHS_PER_YEAR, r.payment)
                 for r in rows if r.payment != 0]
        net = self.borrowed_capital - self.upfront_fees
        return solve_taeg(net, flows)


def solve_taeg(net_capital: Decimal, flows: list[tuple[Decimal, Decimal]]) -> Decimal:
    """Résout `net_capital = somme(montant / (1+t)^annees)` par dichotomie.

    Dichotomie plutôt que Newton : la fonction est monotone décroissante en `t`
    sur [0, 1], donc la dichotomie converge sans dérivée ni cas pathologique, et
    100 itérations suffisent largement pour une précision au 1e-12.
    """
    total = sum((amount for _, amount in flows), Decimal(0))
    if total <= net_capital:
        return Decimal(0)

    def present_value(rate: Decimal) -> Decimal:
        base = Decimal(1) + rate
        return sum(
            (amount / base ** years for years, amount in flows), Decimal(0)
        )

    low, high = Decimal(0), Decimal(1)
    while present_value(high) > net_capital:
        high *= 2
        if high > 100:
            raise ValueError("TAEG hors de portée (> 10000 %)")

    for _ in range(200):
        mid = (low + high) / 2
        if present_value(mid) > net_capital:
            low = mid
        else:
            high = mid
    return (low + high) / 2


# --------------------------------------------------------------------------
# Vérification contre un vrai tableau d'amortissement
# --------------------------------------------------------------------------

RANK_RE = re.compile(r"^\d{3}$")
DATE_RE = re.compile(r"^\d{2}/\d{2}/\d{4}$")
AMOUNT_RE = re.compile(r"^[\d\s\u00a0\u202f]+,\d{2}$")

PAGE_RE = re.compile(r"<page\b.*?</page>", re.S)
LINE_RE = re.compile(r'<line\b[^>]*\byMin="([\d.]+)"[^>]*>(.*?)</line>', re.S)
WORD_RE = re.compile(r'<word\b[^>]*\bxMin="([\d.]+)"[^>]*>([^<]*)</word>')

# Sur une même échéance pdftotext place la date ~1,3 pt plus bas que les
# montants ; deux échéances sont séparées de ~12,6 pt. 3 pt regroupe donc la
# ligne sans mordre sur la suivante.
ROW_BAND_IN_POINTS = 3.0


def parse_amount(text: str) -> Decimal:
    return Decimal(re.sub(r"[\s\u00a0\u202f]", "", text).replace(",", "."))


@dataclass(frozen=True)
class ReferenceRow:
    rank: int
    date: str
    payment: Decimal
    principal: Decimal
    interest: Decimal
    fees: Decimal
    remaining_capital: Decimal
    deferred_interest: Decimal


def parse_reference(path: str) -> list[ReferenceRow]:
    """Lit les échéances d'un tableau d'amortissement PDF.

    On passe par `pdftotext -bbox-layout` et on regroupe les mots par bande
    horizontale plutôt que par la sortie `-layout` : le document porte un
    tampon pivoté à 90° qui, dans le rendu texte, écrase la ligne qu'il
    croise (le rang 34 disparaissait). Avec les coordonnées, le tampon est
    juste un mot de plus dans la bande, qu'aucun motif ne reconnaît.
    """
    if path.lower().endswith(".pdf"):
        raw = subprocess.run(
            ["pdftotext", "-bbox-layout", path, "-"],
            check=True, capture_output=True, text=True, encoding="utf-8",
        ).stdout
    else:
        raw = open(path, encoding="utf-8").read()

    rows: list[ReferenceRow] = []
    for page in PAGE_RE.findall(raw):
        cells = [
            (float(y_min), float(x_min), word)
            for y_min, body in LINE_RE.findall(page)
            for x_min, word in WORD_RE.findall(body)
        ]
        for band in group_by_band(cells):
            row = read_row([word for _, _, word in sorted(band)])
            if row is not None:
                rows.append(row)
    return rows


def group_by_band(cells: list[tuple[float, float, str]]) -> list[list]:
    """Regroupe les mots d'une page en bandes horizontales (une par échéance)."""
    bands: list[list] = []
    top = None
    for cell in sorted(cells):
        if top is None or cell[0] - top > ROW_BAND_IN_POINTS:
            bands.append([])
            top = cell[0]
        bands[-1].append((cell[1], cell[0], cell[2]))
    return bands


def read_row(words: list[str]) -> ReferenceRow | None:
    """Reconstruit une échéance depuis les mots d'une bande, ou None."""
    # Le tampon pivoté tombe dans la marge de gauche : il peut précéder le rang
    # une fois la bande triée par abscisse. On ancre donc sur le couple
    # rang + date plutôt que sur la première position.
    anchor = next(
        (
            i
            for i in range(len(words) - 1)
            if RANK_RE.match(words[i]) and DATE_RE.match(words[i + 1])
        ),
        None,
    )
    if anchor is None:
        return None

    # Les montants sont coupés au séparateur de milliers ("451", "005,29") :
    # on recolle chaque groupe de chiffres au montant qui le suit.
    amounts: list[Decimal] = []
    pending = ""
    for word in words[anchor + 2:]:
        if word.isdigit():
            pending += word
            continue
        if AMOUNT_RE.match(pending + word):
            amounts.append(parse_amount(pending + word))
        pending = ""
    if len(amounts) != 7:
        return None

    return ReferenceRow(
        rank=int(words[anchor]),
        date=words[anchor + 1],
        payment=amounts[0],
        principal=amounts[1],
        interest=amounts[2],
        fees=amounts[3],
        remaining_capital=amounts[4],
        deferred_interest=amounts[5],
    )


def verify(path: str, annual_rate: Decimal) -> int:
    """Rejoue la phase d'amortissement du tableau réel et compare ligne à ligne.

    Le différé du tableau de référence court sur un déblocage progressif dont
    les dates ne figurent pas au document : ses intérêts sont calculés en
    nombre de jours exacts sur 366 et ne sont pas reproductibles à partir des
    seules données de l'offre. On repart donc du capital tel qu'il figure à la
    fin du différé, et on vérifie les 297 échéances d'amortissement.
    """
    reference = parse_reference(path)
    if not reference:
        print(f"aucune ligne d'échéance trouvée dans {path}", file=sys.stderr)
        return 1

    amortising = [r for r in reference if r.payment != 0 and r.principal != 0]
    start_index = reference.index(amortising[0])
    opening_capital = reference[start_index - 1].remaining_capital

    offer = LoanOffer(
        label="référence",
        borrowed_capital=opening_capital,
        annual_nominal_rate=annual_rate,
        total_duration_in_months=len(amortising),
    )
    computed = offer.schedule()

    print(f"Vérification de {path}")
    print(f"  capital en début d'amortissement : {opening_capital} EUR")
    print(f"  taux nominal annuel              : {annual_rate * 100} %")
    print(f"  taux mensuel proportionnel       : {offer.monthly_rate}")
    print(f"  échéances comparées              : {len(amortising)}")
    print(f"  mensualité calculée              : {offer.monthly_repayment} EUR")
    print(f"  mensualité du tableau            : {amortising[0].payment} EUR")

    mismatches = 0
    for expected, actual in zip(amortising, computed):
        for name, want, got in (
            ("mensualité", expected.payment, actual.payment),
            ("capital amorti", expected.principal, actual.principal),
            ("intérêts", expected.interest, actual.interest),
            ("capital restant dû", expected.remaining_capital, actual.remaining_capital),
        ):
            if want != got:
                mismatches += 1
                if mismatches <= 10:
                    print(
                        f"  ÉCART rang {expected.rank} ({expected.date}) {name} : "
                        f"tableau {want} / calculé {got}"
                    )

    # Recoupement avec la ligne TOTAL GENERAL du document, qui ne compte que la
    # phase d'amortissement : les intérêts du différé sont déjà capitalisés
    # dans le capital de départ.
    checks = (
        ("capital amorti",
         sum((r.principal for r in amortising), Decimal(0)),
         sum((r.principal for r in computed), Decimal(0))),
        ("intérêts totaux",
         sum((r.interest for r in amortising), Decimal(0)),
         offer.total_interest(computed)),
        ("total à recouvrer",
         sum((r.payment for r in amortising), Decimal(0)),
         offer.total_paid(computed)),
    )
    for name, want, got in checks:
        flag = "OK " if want == got else "ÉCART"
        print(f"  {flag} {name:<18} : tableau {want} / calculé {got}")
        if want != got:
            mismatches += 1

    if mismatches:
        print(f"ÉCHEC : {mismatches} écart(s)")
        return 1
    print(f"OK : {len(amortising)} échéances identiques au centime près")
    return 0


# --------------------------------------------------------------------------
# Génération des jeux de test
# --------------------------------------------------------------------------

def summarise(offer: LoanOffer) -> dict:
    rows = offer.schedule()
    return {
        "id": offer.id,
        "label": offer.label,
        "borrowed_capital": str(offer.borrowed_capital),
        "annual_nominal_rate": str(offer.annual_nominal_rate),
        "annual_nominal_rate_percent": str(offer.annual_nominal_rate * 100),
        "total_duration_in_months": offer.total_duration_in_months,
        "deferral_in_months": offer.deferral_in_months,
        "deferral_kind": offer.deferral_kind,
        "upfront_fees": str(offer.upfront_fees),
        "monthly_rate": str(offer.monthly_rate),
        "monthly_rate_rounded_1e12": str(
            offer.monthly_rate.quantize(Decimal("1e-12"), rounding=ROUND_HALF_UP)
        ),
        "amortisation_in_months": offer.amortisation_in_months,
        "amortised_capital": str(offer.amortised_capital),
        "monthly_repayment": str(offer.monthly_repayment),
        "last_installment": str(rows[-1].payment),
        "total_interest": str(offer.total_interest(rows)),
        "total_credit_cost": str(offer.total_credit_cost(rows)),
        "total_paid": str(offer.total_paid(rows)),
        "taeg": str(offer.taeg(rows).quantize(Decimal("1e-8"), rounding=ROUND_HALF_UP)),
        "taeg_percent": str(
            (offer.taeg(rows) * 100).quantize(Decimal("1e-6"), rounding=ROUND_HALF_UP)
        ),
        "schedule": [r.as_dict() for r in rows],
    }


def print_summary(offer: LoanOffer) -> None:
    data = summarise(offer)
    rows = offer.schedule()
    print(f"\n=== {offer.label} ===")
    print(f"  capital emprunté          : {data['borrowed_capital']} EUR")
    print(f"  taux nominal annuel       : {data['annual_nominal_rate_percent']} %")
    print(f"  durée totale              : {data['total_duration_in_months']} mois")
    print(f"  différé                   : {data['deferral_in_months']} mois "
          f"({data['deferral_kind']})")
    print(f"  taux mensuel proportionnel: {data['monthly_rate_rounded_1e12']}")
    print(f"  capital amorti (base)     : {data['amortised_capital']} EUR")
    print(f"  mensualité                : {data['monthly_repayment']} EUR "
          f"x {data['amortisation_in_months']}")
    print(f"  dernière échéance         : {data['last_installment']} EUR")
    print(f"  intérêts totaux           : {data['total_interest']} EUR")
    print(f"  frais initiaux            : {data['upfront_fees']} EUR")
    print(f"  coût complet du crédit    : {data['total_credit_cost']} EUR")
    print(f"  total décaissé            : {data['total_paid']} EUR")
    print(f"  TAEG                      : {data['taeg_percent']} %")
    print("  premières échéances :")
    for row in rows[:3]:
        print(f"    {row.rank:>3} {row.phase:<14} éch {row.payment:>9} "
              f"cap {row.principal:>9} int {row.interest:>8} CRD {row.remaining_capital:>12}")
    print("  dernières échéances :")
    for row in rows[-2:]:
        print(f"    {row.rank:>3} {row.phase:<14} éch {row.payment:>9} "
              f"cap {row.principal:>9} int {row.interest:>8} CRD {row.remaining_capital:>12}")


# --------------------------------------------------------------------------
# Rendu Rust
# --------------------------------------------------------------------------

RUST_HEADER = '''\
//! Jeux de test de référence. **Fichier généré, ne pas éditer à la main.**
//!
//! Régénérer avec :
//! `python3 scripts/loan_schedule.py generate --rust {path}`
//!
//! Conventions (taux mensuel proportionnel, arrondi ROUND_HALF_UP au centime,
//! dernière échéance ajustée) vérifiées contre un tableau d'amortissement réel
//! Caisse d'Épargne 2020, et recoupées avec le simulateur de l'ANIL le
//! 2026-08-03. Voir la docstring de `scripts/loan_schedule.py`.

// Les montants sont groupés `euros_centimes` (`149_563_23`) pour rester
// lisibles quand un test échoue. Clippy prend les groupes finaux `_8`, `_16`,
// `_32` et `_64` pour des suffixes de type mal écrits ; l'exception s'arrête à
// ce fichier généré.
#![allow(clippy::mistyped_literal_suffixes)]

use rust_decimal::Decimal;

use crate::euros::Euros;

/// Une ligne de l'échéancier de référence.
// Tous les champs ne sont pas encore lus : les jeux de test précèdent les
// fonctions qu'ils valideront.
#[allow(dead_code)]
#[derive(Debug, PartialEq, Eq)]
pub struct MonthlyInstallment {{
    pub rank: u64,
    pub principal: Euros,
    pub interest: Euros,
    pub remaining_capital: Euros,
}}

/// Une offre de prêt et les valeurs de référence qu'elle doit produire.
#[allow(dead_code)]
#[derive(Debug, PartialEq, Eq)]
pub struct LoanOfferFixture {{
    pub label: &'static str,
    pub borrowed_capital: Euros,
    pub annual_nominal_rate: Decimal,
    pub total_duration_in_months: u64,
    pub deferral_in_months: u64,
    pub monthly_repayment: Euros,
    pub total_credit_cost: Euros,
    pub total_paid: Euros,
    pub taeg: Decimal,
    pub schedule: &'static [MonthlyInstallment],
}}
'''


def rust_string(text: str) -> str:
    """Littéral de chaîne Rust. Les labels contiennent des apostrophes et des
    tirets cadratins, mais jamais de guillemet ni d'antislash."""
    return '"' + text.replace("\\", "\\\\").replace('"', '\\"') + '"'


def rust_euros(value: Decimal) -> str:
    """`Euros::from_cents_as_i64(150_000_00)` : euros groupés par 3, puis les
    centimes, comme le reste du code."""
    cents = int(to_cents(value).scaleb(2))
    sign = "-" if cents < 0 else ""
    digits = str(abs(cents)).zfill(3)
    whole, hundredths = digits[:-2], digits[-2:]
    groups = []
    while len(whole) > 3:
        groups.insert(0, whole[-3:])
        whole = whole[:-3]
    groups.insert(0, whole)
    return f"Euros::from_cents_as_i64({sign}{'_'.join(groups)}_{hundredths})"


def rust_decimal(value: Decimal) -> str:
    """`Decimal::new(mantisse, échelle)`, la forme exacte utilisée par le crate.

    `Decimal::new` refuse une échelle négative, donc on requantifie les valeurs
    dont l'exposant est positif (`1E+2`) avant d'en extraire la mantisse."""
    sign, digits, exponent = value.as_tuple()
    if exponent > 0:
        value = value.quantize(Decimal(1))
        sign, digits, exponent = value.as_tuple()
    mantissa = int("".join(str(d) for d in digits))
    if sign:
        mantissa = -mantissa
    return f"Decimal::new({mantissa}, {-exponent})"


def render_rust(offers: list[LoanOffer], path: str) -> str:
    chunks = [RUST_HEADER.format(path=path)]

    for offer in offers:
        rows = offer.schedule()
        lines = [
            f"\nconst {offer.id.upper()}_SCHEDULE: "
            f"[MonthlyInstallment; {len(rows)}] = ["
        ]
        for row in rows:
            lines.append(
                "    MonthlyInstallment {\n"
                f"        rank: {row.rank},\n"
                f"        principal: {rust_euros(row.principal)},\n"
                f"        interest: {rust_euros(row.interest)},\n"
                f"        remaining_capital: {rust_euros(row.remaining_capital)},\n"
                "    },"
            )
        lines.append("];\n")
        chunks.append("\n".join(lines))

    for offer in offers:
        rows = offer.schedule()
        chunks.append(
            f"\npub fn {offer.id}() -> LoanOfferFixture {{\n"
            "    LoanOfferFixture {\n"
            f"        label: {rust_string(offer.label)},\n"
            f"        borrowed_capital: {rust_euros(offer.borrowed_capital)},\n"
            f"        annual_nominal_rate: {rust_decimal(offer.annual_nominal_rate)},\n"
            f"        total_duration_in_months: {offer.total_duration_in_months},\n"
            f"        deferral_in_months: {offer.deferral_in_months},\n"
            f"        monthly_repayment: {rust_euros(offer.monthly_repayment)},\n"
            f"        total_credit_cost: {rust_euros(offer.total_credit_cost(rows))},\n"
            f"        total_paid: {rust_euros(offer.total_paid(rows))},\n"
            "        taeg: "
            f"{rust_decimal(offer.taeg(rows).quantize(Decimal('1e-8'), rounding=ROUND_HALF_UP))},\n"
            f"        schedule: &{offer.id.upper()}_SCHEDULE,\n"
            "    }\n"
            "}\n"
        )

    calls = "".join(f"        {offer.id}(),\n" for offer in offers)
    chunks.append(
        f"\npub fn all() -> [LoanOfferFixture; {len(offers)}] {{\n"
        f"    [\n{calls}    ]\n"
        "}\n"
    )

    return "".join(chunks)


def sample_offers() -> list[LoanOffer]:
    """Les trois offres anonymisées servant de jeux de test à `immo-core`."""
    return [
        LoanOffer(
            id="offre_a",
            label="Offre A — 150 000 EUR, 3,41 %, 20 ans, sans différé",
            borrowed_capital=Decimal("150000.00"),
            annual_nominal_rate=Decimal("0.0341"),
            total_duration_in_months=240,
        ),
        LoanOffer(
            id="offre_b_differe_total",
            label="Offre B — 439 000 EUR, 2,45 %, 25 ans, 6 mois de différé total",
            borrowed_capital=Decimal("439000.00"),
            annual_nominal_rate=Decimal("0.0245"),
            total_duration_in_months=300,
            deferral_in_months=6,
            deferral_kind=DeferralKind.TOTAL,
        ),
        LoanOffer(
            id="offre_b_differe_partiel",
            label="Offre B' — 439 000 EUR, 2,45 %, 25 ans, 6 mois de différé partiel",
            borrowed_capital=Decimal("439000.00"),
            annual_nominal_rate=Decimal("0.0245"),
            total_duration_in_months=300,
            deferral_in_months=6,
            deferral_kind=DeferralKind.PARTIAL,
        ),
        LoanOffer(
            id="offre_c_ptz",
            label="Offre C — PTZ 95 000 EUR, 0 %, 10 ans, sans différé",
            borrowed_capital=Decimal("95000.00"),
            annual_nominal_rate=Decimal("0"),
            total_duration_in_months=120,
        ),
    ]


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
    sub = parser.add_subparsers(dest="command", required=True)

    check = sub.add_parser("verify", help="comparer à un tableau d'amortissement réel")
    check.add_argument("schedule", help="sortie de `pdftotext -layout` du tableau")
    check.add_argument("--annual-rate", default="0.0115",
                       help="taux nominal annuel du tableau (défaut 0.0115)")

    gen = sub.add_parser("generate", help="produire les jeux de test anonymisés")
    gen.add_argument("--json", help="écrire les échéanciers complets dans ce fichier")
    gen.add_argument("--rust", help="écrire le module de fixtures Rust dans ce fichier")

    args = parser.parse_args()

    if args.command == "verify":
        return verify(args.schedule, Decimal(args.annual_rate))

    offers = sample_offers()
    for offer in offers:
        print_summary(offer)
    if args.json:
        with open(args.json, "w", encoding="utf-8") as handle:
            json.dump([summarise(o) for o in offers], handle,
                      ensure_ascii=False, indent=2)
            handle.write("\n")
        print(f"\néchéanciers complets écrits dans {args.json}")
    if args.rust:
        with open(args.rust, "w", encoding="utf-8") as handle:
            handle.write(render_rust(offers, args.rust))
        print(f"\nmodule de fixtures Rust écrit dans {args.rust}")
    return 0


if __name__ == "__main__":
    sys.exit(main())