CHAPITRE 29 – INTERPRETER

// --- LA GRAMMAIRE (AST) ---
// Expression : l'interface de base pour tous les noeuds de l'arbre.
interface Expression {
    interpret(context: Context): boolean;
}

// Expressions terminales (feuilles)
class Variable implements Expression {
    constructor(private name: string) {}
    interpret(context: Context): boolean {
        return context.get(this.name);
    }
}

class Constante implements Expression {
    constructor(private value: boolean) {}
    interpret(context: Context): boolean {
        return this.value;
    }
}

// Expressions non terminales (noeuds)
class Et implements Expression {
    constructor(private left: Expression, private right: Expression) {}
    interpret(context: Context): boolean {
        return this.left.interpret(context) && this.right.interpret(context);
    }
}

class Ou implements Expression {
    constructor(private left: Expression, private right: Expression) {}
    interpret(context: Context): boolean {
        return this.left.interpret(context) || this.right.interpret(context);
    }
}

class Non implements Expression {
    constructor(private expr: Expression) {}
    interpret(context: Context): boolean {
        return !this.expr.interpret(context);
    }
}

// Contexte : fournit les valeurs des variables
class Context {
    private variables: Map<string, boolean> = new Map();
    set(name: string, value: boolean): void {
        this.variables.set(name, value);
    }
    get(name: string): boolean {
        if (!this.variables.has(name)) {
            throw new Error(`Variable inconnue: ${name}`);
        }
        return this.variables.get(name)!;
    }
}

// --- PARSER (simplifié à mort) ---
// Dans la vraie vie, on utilise un vrai parser (recursive descent, etc.).
// Ici, on simule la construction de l'AST à la main pour l'exemple.
class ParserSimple {
    // Parse une expression comme "(alarmeActive AND porteOuverte) OR NOT systemeArme"
    // C'est TRÈS simplifié et ne gère pas la vraie syntaxe.
    static parse(tokens: string[], context: Context): Expression {
        // Algorithme naïf qui suppose une forme spécifique.
        // Un vrai parser est bien plus complexe.
        let i = 0;
        const parseExpression = (): Expression => {
            const token = tokens[i++];
            if (token === '(') {
                const left = parseExpression();
                const op = tokens[i++];
                const right = parseExpression();
                i++; // consommer ')'
                if (op === 'AND') return new Et(left, right);
                if (op === 'OR') return new Ou(left, right);
                throw new Error(`Opérateur inattendu: ${op}`);
            }
            if (token === 'NOT') {
                return new Non(parseExpression());
            }
            // C'est une variable ou une constante
            if (token === 'true') return new Constante(true);
            if (token === 'false') return new Constante(false);
            // Sinon, c'est une variable
            return new Variable(token);
        };
        return parseExpression();
    }
}

// --- SCÉNARIO : SYSTÈME D'ALARME INTELLIGENT ---
console.log("=== INTERPRÉTEUR D'EXPRESSIONS BOOLÉENNES (Interpreter Pattern) ===\n");

// Définition du contexte (état du système)
const contexteAlarme = new Context();
contexteAlarme.set('alarmeActive', true);
contexteAlarme.set('porteOuverte', false);
contexteAlarme.set('fenetreOuverte', false);
contexteAlarme.set('systemeArme', true);
contexteAlarme.set('mouvement', true);

console.log("État du système:");
contexteAlarme.set('alarmeActive', true);
contexteAlarme.set('porteOuverte', false);
contexteAlarme.set('fenetreOuverte', true);
contexteAlarme.set('systemeArme', true);
contexteAlarme.set('mouvement', false);

// Construction MANUELLE de l'AST (en vrai, on le ferait via un parser).
// Expression: (porteOuverte OR fenetreOuverte) AND alarmeActive AND systemeArme
const ast1 = new Et(
    new Ou(new Variable('porteOuverte'), new Variable('fenetreOuverte')),
    new Et(new Variable('alarmeActive'), new Variable('systemeArme'))
);

console.log("\n--- Règle 1: Alarme déclenchée si une entrée est ouverte ET alarme active ET système armé ---");
console.log(`AST: (porteOuverte OR fenetreOuverte) AND alarmeActive AND systemeArme`);
const resultat1 = ast1.interpret(contexteAlarme);
console.log(`Résultat: ${resultat1} → Alarme ${resultat1 ? '🚨 DÉCLENCHÉE' : 'silencieuse'}`);

// Autre expression: mouvement AND NOT systemeArme
const ast2 = new Et(
    new Variable('mouvement'),
    new Non(new Variable('systemeArme'))
);

console.log("\n--- Règle 2: Alerte si mouvement détecté ET système désarmé ---");
console.log(`AST: mouvement AND NOT systemeArme`);
contexteAlarme.set('systemeArme', false); // On désarme le système
const resultat2 = ast2.interpret(contexteAlarme);
console.log(`Résultat: ${resultat2} → Alerte ${resultat2 ? '⚠️ ACTIVÉE' : 'inactive'}`);

// --- Démonstration avec un "parser" simplifié ---
console.log("\n=== Utilisation avec un parser (très simplifié) ===");
// On simule des tokens pour l'expression: (alarmeActive AND porteOuverte) OR NOT systemeArme
const tokens = ['(', 'alarmeActive', 'AND', 'porteOuverte', ')', 'OR', 'NOT', 'systemeArme'];
try {
    const astParsed = ParserSimple.parse(tokens, contexteAlarme);
    console.log(`Expression parsée depuis tokens: ${tokens.join(' ')}`);
    const resultatParsed = astParsed.interpret(contexteAlarme);
    console.log(`Résultat: ${resultatParsed}`);
} catch (e) {
    console.error(`Erreur de parsing: ${e}`);
}