// profile.ts — playful CV-as-code 

type Cloud = "aws" | "gcp" | "azure" | "on-prem";
type SearchStack = "elasticsearch" | "solr";
type Db = "mysql" | "postgresql" | "oracle" | "sqlserver";
type Lang = "fr" | "en";

type LatencyBudget = { p50: number; p95: number; p99: number };
type SLO = { availability: string; latency: LatencyBudget; errorRate: string };

type LLMProvider = "openai" | "groq" | "anthropic" | "ollama";
type LLMTask =
  | "chat"
  | "rag"
  | "routing"
  | "tool_use"
  | "voice"
  | "sql_generation";

type Drift = "data" | "concept" | "prompt" | "model";

interface RAGPolicy {
  chunking: "semantic" | "fixed";
  retrieval: "bm25" | "hybrid";
  citeSources: boolean;
  maxTokens: number;
}

interface Budget {
  capUSDPerMonth: number;
  capTokensPerDay: number;
}

interface BenchResult {
  task: LLMTask;
  latencyMs: number;
  quality: number; // 0..100
  costUSD: number;
}

// Nouveauté : Ajout d'un type générique pour les benchmarks, pour plus de flexibilité warrior-style
type BenchResultGeneric<T extends LLMTask> = {
  task: T;
  latencyMs: number;
  quality: number;
  costUSD: number;
  extraMetrics?: Record<string, number>; // Extensible pour d'autres métriques
};

class ChiefDataAIOfficer {
  private years = 19;
  private centersOfExcellence = ["platform", "search", "data", "mlops", "llm"] as const;
  private slo: SLO = {
    availability: "99.9%",
    latency: { p50: 120, p95: 250, p99: 600 },
    errorRate: "<0.5%",
  };

  public readonly name = "Augustin de Préville";
  public readonly role = "Chief Data & AI Officer";
  public readonly location = "Paris, France";
  public readonly languages: Lang[] = ["fr", "en"];

  // Core stacks
  public readonly clouds: Cloud[] = ["aws"];
  public readonly dbs: Db[] = ["mysql", "postgresql", "oracle", "sqlserver"];
  public readonly search: SearchStack[] = ["elasticsearch", "solr"];
  public readonly backends = ["symfony", "nodejs-utility"] as const;
  public readonly frontend = ["angular", "react", "pwa"] as const;
  public readonly devops = ["docker", "kubernetes", "gitlab-ci", "helm", "prometheus", "sentry"] as const;

  // LLM stack
  public readonly providers: LLMProvider[] = ["openai", "groq", "anthropic", "ollama"];
  public readonly ragPolicy: RAGPolicy = {
    chunking: "semantic",
    retrieval: "hybrid",
    citeSources: true,
    maxTokens: 2048,
  };

  // Governance
  private budget: Budget = { capUSDPerMonth: 3000, capTokensPerDay: 5_000_000 };
  private cirCertifiedYears = 10; // R&D program leadership

  getSnapshot() {
    return {
      role: this.role,
      years: this.years,
      centers: [...this.centersOfExcellence],
      slo: this.slo,
      stacks: {
        clouds: this.clouds,
        dbs: this.dbs,
        search: this.search,
        backends: this.backends,
        frontend: this.frontend,
        devops: this.devops,
      },
      llm: { providers: this.providers, ragPolicy: this.ragPolicy },
      governance: { budget: this.budget, cirCertifiedYears: this.cirCertifiedYears },
    };
  }

  // Routing policy: pick the right model/provider based on task + constraints
  routePrompt(task: LLMTask, tokens: number, needDeterminism = false): { provider: LLMProvider; model: string } {
    // toy policy for demo
    if (task === "rag") return { provider: "openai", model: "gpt-4o-mini" };
    if (task === "voice") return { provider: "openai", model: "gpt-4o-realtime" };
    if (task === "sql_generation") return { provider: "anthropic", model: "claude-3.5-sonnet" };
    if (needDeterminism || tokens > 200_000) return { provider: "ollama", model: "llama3.1:70b-instruct-q5" };
    return { provider: "groq", model: "llama3.1-70b" };
  }

  // Bench a provider/model pair (toy deterministic function)
  bench<T extends LLMTask>(task: T): BenchResultGeneric<T> {
    const baseLatency = { chat: 160, rag: 190, routing: 80, tool_use: 220, voice: 140, sql_generation: 260 }[task];
    const quality = { chat: 92, rag: 90, routing: 85, tool_use: 88, voice: 91, sql_generation: 89 }[task];
    const cost = { chat: 0.003, rag: 0.005, routing: 0.001, tool_use: 0.004, voice: 0.006, sql_generation: 0.004 }[task];
    return { task, latencyMs: baseLatency, quality, costUSD: cost };
  }

  // MLOps lifecycle — simplified orchestra
  async deployModel(name: string, sha: string) {
    const checks = ["unit", "integration", "bias", "security"] as const;
    const passed = checks.every(() => true);
    if (!passed) throw new Error("quality gates failed");
    await new Promise((r) => setTimeout(r, 42));
    return { name, sha, strategy: "canary", traffic: "10% → 50% → 100%", rollback: "auto on regression" };
  }

  // Drift detection (toy)
  detectDrift(kind: Drift, metric: number) {
    const threshold = { data: 0.15, concept: 0.1, prompt: 0.2, model: 0.08 }[kind];
    return { kind, metric, threshold, drift: metric > threshold };
  }

  // RAG configuration check
  checkRAG(policy: Partial<RAGPolicy> = {}) {
    const cfg = { ...this.ragPolicy, ...policy };
    const ok = cfg.retrieval === "hybrid" && cfg.citeSources;
    return { cfg, status: ok ? "ready" : "needs_review" };
  }

  // Executive summary (because boards love bullets)
  boardSlide() {
    return [
      `AI/LLM: routing multi-fournisseurs, RAG avec citations, agents out-of-process`,
      `MLOps: évaluation, dérive, CI/CD modèles & prompts, canary/rollback`,
      `Plateformes: APIs first, recherche, perf & SLOs, sécurité by design`,
      `R&D: ${this.cirCertifiedYears} ans de centre certifié CIR (industrialisation IA)`,
    ];
  }

  // Easter egg: generator that streams “value creation” like log lines
  *valueStream() {
    yield "[ok] data contracts enforced";
    yield "[ok] search relevance +27% after synonym tuning";
    yield "[ok] latency p95 down to 230ms (budget 250ms)";
    yield "[ok] hallucination rate -8% with grounding+reranking";
    yield "[ok] cost per answer -32% via routing & caching";
  }

  // Nouveauté : Méthode pour comparer deux benchmarks, avec typing strict
  compareBenches<T extends LLMTask>(bench1: BenchResultGeneric<T>, bench2: BenchResultGeneric<T>): { deltaLatency: number; deltaQuality: number; deltaCost: number } {
    return {
      deltaLatency: bench1.latencyMs - bench2.latencyMs,
      deltaQuality: bench1.quality - bench2.quality,
      deltaCost: bench1.costUSD - bench2.costUSD,
    };
  }
}

// --- demo usage ---
const cdao = new ChiefDataAIOfficer();

console.log("== SNAPSHOT ==");
console.log(cdao.getSnapshot());

console.log("\n== ROUTING SAMPLE ==");
console.log("rag →", cdao.routePrompt("rag", 800));
console.log("sql_generation →", cdao.routePrompt("sql_generation", 1200, true));

console.log("\n== BENCHES ==");
(["rag", "chat", "tool_use"] as LLMTask[]).forEach(t => console.log(t, cdao.bench(t)));

// Nouveauté dans demo : Comparaison de benches
const benchRag = cdao.bench("rag");
const benchChat = cdao.bench("chat");
console.log("\n== COMPARE BENCHES ==");
console.log("rag vs chat →", cdao.compareBenches(benchRag, benchChat));

console.log("\n== DEPLOY ==");
cdao.deployModel("search-relevancy-rlhf", "a1b2c3d").then(r => console.log(r));

console.log("\n== DRIFT ==");
console.log(cdao.detectDrift("data", 0.11));
console.log(cdao.detectDrift("concept", 0.12));

console.log("\n== RAG CHECK ==");
console.log(cdao.checkRAG({ retrieval: "hybrid", citeSources: true }));

console.log("\n== BOARD SLIDE ==");
console.log(cdao.boardSlide().map(b => "• " + b).join("\n"));

console.log("\n== VALUE STREAM ==");
for (const line of cdao.valueStream()) console.log(line);