CHAPITRE 8 : BUILDER

// L'ANTI-PATTERN : Le constructeur télescope.
class Commande {
    constructor(
        public clientId: string,
        public items: LigneCommande[],
        public adresseLivraison: Adresse,
        public adresseFacturation: Adresse | null,
        public modePaiement: string,
        public codePromo: string | null,
        public estExpress: boolean,
        // ... 8 autres paramètres ...
    ) {
        // La validation devient un enfer. L'ordre des paramètres est crucial.
    }
}
// Création illisible et sujette aux erreurs.
const c = new Commande('client123', items, adrLiv, adrFac, 'CARD', null, true, ...);

// 1. Le Produit Complexe
class Commande {
    // Notez : les propriétés peuvent être privées et finales (immutables).
    constructor(
        public readonly clientId: string,
        public readonly items: readonly LigneCommande[],
        public readonly adresseLivraison: Adresse,
        public readonly adresseFacturation: Adresse,
        public readonly modePaiement: string,
        public readonly codePromo?: string,
        public readonly estExpress: boolean = false
    ) {}
}

// 2. L'Interface Builder (contrat de construction étape par étape)
interface CommandeBuilder {
    setClient(clientId: string): this;
    ajouterItem(produitId: string, quantite: number): this;
    setAdresseLivraison(adresse: Adresse): this;
    setAdresseFacturation(adresse: Adresse): this;
    utiliserModePaiement(mode: string): this;
    appliquerCodePromo(code: string): this;
    marquerExpress(): this;
    build(): Commande; // L'étape finale qui produit l'objet.
}

// 3. Le Concrete Builder (implémentation par défaut)
class ConcreteCommandeBuilder implements CommandeBuilder {
    private clientId?: string;
    private items: LigneCommande[] = [];
    private adresseLivraison?: Adresse;
    private adresseFacturation?: Adresse;
    private modePaiement: string = 'CARTE';
    private codePromo?: string;
    private estExpress: boolean = false;

    setClient(clientId: string): this {
        // Validation possible
        if (!clientId) throw new Error('Client invalide');
        this.clientId = clientId;
        return this; // Retourne `this` pour le chaînage fluide.
    }

    ajouterItem(produitId: string, quantite: number): this {
        this.items.push(new LigneCommande(produitId, quantite));
        return this;
    }

    setAdresseLivraison(adresse: Adresse): this {
        this.adresseLivraison = adresse;
        // Si l'adresse de facturation n'est pas encore définie, on la copie.
        if (!this.adresseFacturation) {
            this.adresseFacturation = adresse;
        }
        return this;
    }

    setAdresseFacturation(adresse: Adresse): this {
        this.adresseFacturation = adresse;
        return this;
    }

    utiliserModePaiement(mode: string): this {
        this.modePaiement = mode;
        return this;
    }

    appliquerCodePromo(code: string): this {
        this.codePromo = code;
        return this;
    }

    marquerExpress(): this {
        this.estExpress = true;
        return this;
    }

    // Méthode finale qui valide et construit l'objet immuable.
    build(): Commande {
        // VALIDATION CENTRALISÉE
        if (!this.clientId) throw new Error('Client manquant');
        if (this.items.length === 0) throw new Error('Panier vide');
        if (!this.adresseLivraison) throw new Error('Adresse manquante');
        // Logique métier complexe peut être ici (calcul de réduction, etc.)

        return new Commande(
            this.clientId,
            [...this.items], // Copie pour éviter les modifications externes
            this.adresseLivraison,
            this.adresseFacturation!,
            this.modePaiement,
            this.codePromo,
            this.estExpress
        );
    }
}

// 4. Le Directeur (Optionnel - pour encapsuler des recettes de construction communes)
class DirecteurCommandes {
    static construireCommandeExpress(clientId: string, itemPrincipal: string): Commande {
        return new ConcreteCommandeBuilder()
            .setClient(clientId)
            .ajouterItem(itemPrincipal, 1)
            .marquerExpress()
            .setAdresseLivraison(Adresse.USINE) // Adresse prédéfinie
            .utiliserModePaiement('EXPRESS_PAY')
            .build();
    }

    static construireCommandeStandard(clientId: string): CommandeBuilder {
        // Peut aussi retourner le builder pour personnalisation ultérieure.
        return new ConcreteCommandeBuilder().setClient(clientId);
    }
}

// 5. UTILISATION PAR LE CLIENT
// Méthode fluide, claire, étape par étape.
const commande1: Commande = new ConcreteCommandeBuilder()
    .setClient('client_789')
    .ajouterItem('livre_456', 2)
    .ajouterItem('cafe_123', 1)
    .setAdresseLivraison(new Adresse('123 Rue Principale', 'Paris'))
    .appliquerCodePromo('ETE2024')
    .build();
console.log(commande1); // Commande immuable et valide.

// Utilisation du Directeur pour une recette prédéfinie.
const commandeExpress = DirecteurCommandes.construireCommandeExpress('client_555', 'urgent_001');
console.log(commandeExpress);

// Construction personnalisée avec le Directeur qui retourne un Builder.
const builder = DirecteurCommandes.construireCommandeStandard('client_999');
const commande2 = builder
    .ajouterItem('produit_x', 5)
    .setAdresseFacturation(new Adresse('Siège Social', 'Lyon'))
    .build();