CHAPITRE 12 : BRIDGE

// AVANT : L'ENFER COMBINATOIRE (Approche par héritage unique)
abstract class Forme {
    abstract dessiner(): void;
}

class CercleRouge extends Forme {
    dessiner() { console.log("Dessiner un cercle ROUGE"); }
}
class CercleBleu extends Forme {
    dessiner() { console.log("Dessiner un cercle BLEU"); }
}
class RectangleRouge extends Forme {
    dessiner() { console.log("Dessiner un rectangle ROUGE"); }
}
class RectangleBleu extends Forme {
    dessiner() { console.log("Dessiner un rectangle BLEU"); }
}
// Ajouter une nouvelle forme ? Il faut CercleVert, RectangleVert, etc.
// Ajouter une nouvelle couleur ? Il faut *chaque forme* dans cette couleur.
// 3 formes x 4 couleurs = 12 classes. C'est ingérable.

// --- HIÉRARCHIE D'IMPLÉMENTATION (La plateforme) ---
// C'est le "comment". Peut varier indépendamment.
interface Rendu {
    dessinerCercle(rayon: number): void;
    dessinerRectangle(largeur: number, hauteur: number): void;
}

// Implémentations concrètes pour différentes plates-formes.
class RenduWindows implements Rendu {
    dessinerCercle(rayon: number): void {
        console.log(`[Windows API] Dessine un cercle de rayon ${rayon}`);
    }
    dessinerRectangle(largeur: number, hauteur: number): void {
        console.log(`[Windows API] Dessine un rectangle ${largeur}x${hauteur}`);
    }
}

class RenduMac implements Rendu {
    dessinerCercle(rayon: number): void {
        console.log(`[macOS Core Graphics] Dessine un cercle de rayon ${rayon}`);
    }
    dessinerRectangle(largeur: number, hauteur: number): void {
        console.log(`[macOS Core Graphics] Dessine un rectangle ${largeur}x${hauteur}`);
    }
}

// --- HIÉRARCHIE D'ABSTRACTION (Les formes) ---
// C'est le "quoi". Peut être étendu sans toucher au rendu.
abstract class Forme {
    // LE PONT : Référence à l'implémentation.
    protected constructor(protected rendu: Rendu) {}

    abstract dessiner(): void; // Méthode de haut niveau.
    abstract redimensionner(facteur: number): void; // Peut utiliser le rendu.
}

class Cercle extends Forme {
    private rayon: number;

    constructor(rendu: Rendu, rayon: number) {
        super(rendu);
        this.rayon = rayon;
    }

    dessiner(): void {
        // L'abstraction délègue le travail concret à l'implémentation.
        this.rendu.dessinerCercle(this.rayon);
    }

    redimensionner(facteur: number): void {
        this.rayon *= facteur;
        console.log(`Cercle redimensionné. Nouveau rayon: ${this.rayon}`);
    }
}

class Rectangle extends Forme {
    constructor(
        rendu: Rendu,
        private largeur: number,
        private hauteur: number
    ) {
        super(rendu);
    }

    dessiner(): void {
        this.rendu.dessinerRectangle(this.largeur, this.hauteur);
    }

    redimensionner(facteur: number): void {
        this.largeur *= facteur;
        this.hauteur *= facteur;
        console.log(`Rectangle redimensionné. Nouvelles dimensions: ${this.largeur}x${this.hauteur}`);
    }
}

// --- UTILISATION ---
// Configuration à l'exécution : on choisit la plateforme.
const estSurMac = true;
const moteurDeRendu: Rendu = estSurMac ? new RenduMac() : new RenduWindows();

// On crée des formes, en leur passant le moteur de rendu approprié.
const formes: Forme[] = [
    new Cercle(moteurDeRendu, 5),
    new Rectangle(moteurDeRendu, 10, 20),
    new Cercle(moteurDeRendu, 8)
];

// Le client travaille uniquement avec l'abstraction (Forme).
// Il ne sait pas si c'est Windows, Mac, ou autre.
formes.forEach(forme => forme.dessiner());
// Si estSurMac = true, affiche :
// [macOS Core Graphics] Dessine un cercle de rayon 5
// [macOS Core Graphics] Dessine un rectangle 10x20
// [macOS Core Graphics] Dessine un cercle de rayon 8

// Ajouter une nouvelle forme (Triangle) ? On ajoute une classe `Triangle` qui étend `Forme`.
// Ajouter une nouvelle plateforme (Linux) ? On ajoute une classe `RenduLinux` qui implémente `Rendu`.
// AUCUNE MODIFICATION des classes existantes. C'est le principe Ouvert/Fermé en action.

       +-------------+          "a un"        +------------+
       |  Abstraction |<>-------------------> | Implémentation |
       +-------------+      (référence)      +------------+
               ^                                      ^
               |                                      |
    +----------+----------+               +-----------+-----------+
    |                     |               |                       |
+---------+         +----------+    +------------+         +------------+
| Raffiné A|         |Raffiné B|    |Implémentation A|     |Implémentation B|
+---------+         +----------+    +------------+         +------------+
(Ex: Cercle)        (Ex: Rectangle) (Ex: RenduWindows)    (Ex: RenduMac)