// ❌ Problème sans contrainte
function logLength<T>(arg: T) {
  console.log(arg.length); // ❌ Erreur: T n'a pas .length
}

// ✅ Avec contrainte extends
function logLength<T extends { length: number }>(arg: T): T {
  console.log(arg.length); // ✓ TypeScript garantit .length
  return arg;
}
logLength("hello");    // ✓ string a .length
logLength([1,2,3]);  // ✓ array a .length
logLength(42);       // ❌ Erreur: number n'a pas .length

// keyof + Lookup Types — getProperty type-safe
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}
const user = { name: "Ana", age: 28 };
const name = getProperty(user, "name"); // → string ✓
const age  = getProperty(user, "age");  // → number ✓
// getProperty(user, "salary") ❌ — "salary" n'existe pas

class Stack<T> {
  private items: T[] = [];

  push(item: T): void      { this.items.push(item); }
  pop(): T | undefined      { return this.items.pop(); }
  peek(): T | undefined     { return this.items.at(-1); }
  get size(): number          { return this.items.length; }
  isEmpty(): boolean          { return this.items.length === 0; }
}

// T = number — inféré dès le premier push ou annoté explicitement
const numStack = new Stack<number>();
numStack.push(1); numStack.push(2); numStack.push(3);
const top = numStack.peek(); // number | undefined ✓
// numStack.push("hello");   ❌ string pas assignable à number

// Stack d'objets pour l'historique de navigation
const history = new Stack<{ url: string; ts: number }>();
history.push({ url: "/home", ts: Date.now() });

// Interface générique — contrat pour tous les Repositories
interface Repository<T, ID = number> {
  findById(id: ID):             Promise<T | null>;
  findAll():                     Promise<T[]>;
  save(entity: Omit<T, "id">):  Promise<T>;
  update(id: ID, data: Partial<T>): Promise<T>;
  delete(id: ID):              Promise<void>;
}

// Implémentation in-memory (idéale pour les tests unitaires)
class InMemoryRepo<T extends { id: number }> implements Repository<T> {
  private store = new Map<number, T>();
  private nextId = 1;

  async findById(id: number) { return this.store.get(id) ?? null; }
  async findAll()             { return [...this.store.values()]; }
  async save(entity: Omit<T, "id">) {
    const full = { ...entity, id: this.nextId++ } as T;
    this.store.set(full.id, full); return full;
  }
  async update(id: number, data: Partial<T>) {
    const updated = { ...this.store.get(id)!, ...data };
    this.store.set(id, updated); return updated;
  }
  async delete(id: number) { this.store.delete(id); }
}

type User    = { id: number; name: string; email: string };
type Product = { id: number; title: string; price: number };

const userRepo    = new InMemoryRepo<User>();
const productRepo = new InMemoryRepo<Product>();

// États de fetch — Discriminated Union avec Generic
type FetchState<T> =
  | { status: "idle"    }
  | { status: "loading" }
  | { status: "success"; data: T     }
  | { status: "error";   error: string };

function render<T>(state: FetchState<T>) {
  switch (state.status) {
    case "idle":    return "Prêt";
    case "loading": return "Chargement…";
    case "success": return `OK: ${state.data}`; // data est typé T ✓
    case "error":   return `Erreur: ${state.error}`;
  }
}

// Système d'événements typés — pattern Event Bus
type AppEvent =
  | { type: "USER_LOGIN";   userId: string; ip: string }
  | { type: "ORDER_PLACED"; orderId: string; amount: number }
  | { type: "PAYMENT_DONE"; txId: string; method: "card" | "paypal" };

function handle(evt: AppEvent): void {
  switch (evt.type) {
    case "USER_LOGIN":
      console.log(evt.userId, evt.ip);   // ✓ accès type-safe
      break;
    case "ORDER_PLACED":
      console.log(evt.amount);           // ✓ number
      break;
    case "PAYMENT_DONE":
      console.log(evt.method);           // ✓ "card" | "paypal"
      break;
    default:
      const _: never = evt; // exhaustivity check ✓
  }
}

type User = {
  id: number; name: string; email: string;
  password: string; role: "admin" | "user"; createdAt: Date;
};

// Partial — toutes les props optionnelles (PATCH requests)
type UpdateUser = Partial<User>;

// Pick — sélectionner un sous-ensemble (vue publique)
type UserPublic = Pick<User, "id" | "name" | "role">;

// Omit — exclure des props (sécurité)
type UserView   = Omit<User, "password">;
type CreateUser = Omit<User, "id" | "createdAt">;

// Record — dictionnaire type-safe
type RolePerms = Record<"admin" | "user", string[]>;
const perms: RolePerms = {
  admin: ["read", "write", "delete"],
  user:  ["read"],
};

// Composition — la vraie puissance
type UpdateDto = Partial<Omit<User, "id" | "createdAt">>
              & Pick<User, "id">;

// NonNullable, Extract, Exclude
type Safe   = NonNullable<string | null>;  // string
type Only   = Extract<string|number|boolean, string|number>; // string | number
type NoNull = Exclude<string|null|undefined, null|undefined>; // string

// ReturnType — type de retour sans redéclarer
function createUser(name: string, age: number) {
  return { id: Math.random(), name, age, active: true };
}
type UserFromFactory = ReturnType<typeof createUser>;
// { id: number; name: string; age: number; active: boolean }

// Parameters — tuple des paramètres
type CreateArgs = Parameters<typeof createUser>;
// [name: string, age: number]

// Awaited — résoudre les Promises imbriquées
async function fetchUser(id: number) {
  return fetch(`/api/users/${id}`).then(r => r.json() as Promise<{ id: number; name: string }>);
}
type FetchedUser = Awaited<ReturnType<typeof fetchUser>>;
// { id: number; name: string }  — Promise résolue ✓

// InstanceType — type d'une instance de classe
class ApiClient {
  constructor(private baseUrl: string, private token: string) {}
  get(path: string) { return fetch(this.baseUrl + path); }
}
type Client     = InstanceType<typeof ApiClient>;
type ClientArgs = ConstructorParameters<typeof ApiClient>;
// [baseUrl: string, token: string]

// ── lib/api.ts — fonctions de fetch ──────────────
async function getUser(id: string) {
  const res = await fetch(`/api/users/${id}`);
  return res.json() as Promise<{
    id: string; name: string; role: "admin" | "user"; posts: number;
  }>;
}

// ✅ Type inféré UNE SEULE FOIS — jamais désynchronisé
type User = Awaited<ReturnType<typeof getUser>>;

// ── Server Action — même pattern ─────────────────
async function createPost(title: string, body: string) {
  return { id: crypto.randomUUID(), title, body, createdAt: new Date() };
}
type Post        = Awaited<ReturnType<typeof createPost>>;
type PostPayload = Parameters<typeof createPost>;
// [title: string, body: string]

// ── Pattern générique pour tous les loaders ──────
type PageProps<TLoader extends (...args: any[]) => any> = {
  data: Awaited<ReturnType<TLoader>>;
};

type UserPageProps = PageProps<typeof getUser>;
// { data: User } — type parfaitement inféré ✓

// T extends U ? TypeSiVrai : TypeSiFaux
type IsString<T> = T extends string ? "yes" : "no";
type A = IsString<string>;  // "yes"
type B = IsString<number>;  // "no"

// Distribution sur les unions (naked type parameter)
type ToArray<T> = T extends any ? T[] : never;
type C = ToArray<string | number>; // string[] | number[]

// Désactiver la distribution avec des wrappers [T]
type NoDistrib<T> = [T] extends [any] ? T[] : never;
type D = NoDistrib<string | number>; // (string | number)[]

// Types utilitaires maison avec Conditional Types
type Flatten<T>        = T extends (infer U)[] ? U : T;
type MyNonNullable<T> = T extends null | undefined ? never : T;
type E = Flatten<string[]>; // string
type F = Flatten<number>;   // number (pas un tableau)

// IsNever — détecter le type never
type IsNever<T> = [T] extends [never] ? true : false;
type A = IsNever<never>;  // true
type B = IsNever<string>; // false
// Note : sans wrapper [T], IsNever<never> serait never lui-même !

// DeepRequired — rendre tout obligatoire en profondeur
type DeepRequired<T> = {
  [K in keyof T]-?: T[K] extends object
    ? DeepRequired<T[K]>
    : NonNullable<T[K]>;
};

// PickByValue — garder uniquement les props d'un certain type
type PickByValue<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K]
};

type Form = { name: string; age: number; email: string; score: number };
type StringFields = PickByValue<Form, string>;
// { name: string; email: string }

// UnionToIntersection — convertir union en intersection
type UnionToIntersection<U> =
  (U extends any ? (x: U) => void : never) extends
  (x: infer I) => void ? I : never;

type ABC = { a: string } | { b: number } | { c: boolean };
type ABCI = UnionToIntersection<ABC>;
// { a: string } & { b: number } & { c: boolean }

// Modificateurs +/- readonly et +/- ?
type MyReadonly<T>  = { readonly [K in keyof T]: T[K] };
type Mutable<T>    = { -readonly [K in keyof T]: T[K] };
type MyPartial<T>  = { [K in keyof T]?: T[K] };
type MyRequired<T> = { [K in keyof T]-?: T[K] };

// Key remapping avec as — renommer dynamiquement les clés
type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K]
};
type User        = { name: string; age: number };
type UserGetters = Getters<User>;
// { getName: () => string; getAge: () => number }

// Filtrer des clés avec never dans as
type OnlyStrings<T> = {
  [K in keyof T as T[K] extends string ? K : never]: T[K]
};
type Config       = { host: string; port: number; name: string };
type StringConfig = OnlyStrings<Config>; // { host: string; name: string }

// ── FormState — erreurs et touched dérivés du type form ──
type FormState<T> = {
  values:  T;
  errors:  { [K in keyof T]?:  string  }; // optionnel par champ
  touched: { [K in keyof T]:   boolean }; // requis par champ
  dirty:   { [K in keyof T]:   boolean };
};

type Login = { email: string; password: string; remember: boolean };
type LoginState = FormState<Login>;
// errors: { email?: string; password?: string; remember?: string }
// touched: { email: boolean; password: boolean; remember: boolean }

// ── TypedEmitter — EventEmitter complètement type-safe ────
type SocketEvents = {
  connect:    { clientId: string; ip: string };
  disconnect: { clientId: string; reason: string };
  message:    { from: string; content: string; ts: number };
};

type TypedEmitter<E extends Record<string, object>> = {
  on<K extends keyof E>(event: K, fn: (d: E[K]) => void): void;
  emit<K extends keyof E>(event: K, data: E[K]): void;
  off<K extends keyof E>(event: K, fn: (d: E[K]) => void): void;
};

declare const ws: TypedEmitter<SocketEvents>;
ws.on("connect", (d) => console.log(d.clientId, d.ip));   // ✓
ws.on("message", (d) => console.log(d.from, d.content));  // ✓
// ws.on("ping", …) ❌ "ping" n'existe pas dans SocketEvents
// ws.emit("connect", { ip: "x" }) ❌ clientId manquant !

// Unions de strings générées automatiquement
type Dir        = "top" | "right" | "bottom" | "left";
type CSSPadding = `padding-${Dir}`;
// "padding-top" | "padding-right" | "padding-bottom" | "padding-left"

// Intrinsic string types
type Events   = "click" | "focus" | "blur";
type Handlers = `on${Capitalize<Events>}`;
// "onClick" | "onFocus" | "onBlur"

// PropEventSource — payload typé depuis le nom d'événement
type Watchable<T> = {
  on<K extends string & keyof T>(
    event: `${K}Changed`,
    fn: (val: T[K]) => void
  ): void;
};

declare function makeWatchable<T>(v: T): T & Watchable<T>;
const user = makeWatchable({ name: "Ana", age: 28 });
user.on("nameChanged", (v) => console.log(v)); // v: string ✓
user.on("ageChanged",  (v) => console.log(v)); // v: number ✓
// user.on("emailChanged", …) ❌ "email" n'existe pas

// Parser des routes — RouteParams
type Params<T extends string> =
  T extends `${string}:${infer P}/${infer R}` ? P | Params<`/${R}`>
  : T extends `${string}:${infer P}` ? P : never;

type R = Params<"/users/:id/posts/:postId">; // "id" | "postId"

// Head — premier élément d'un tuple
type Head<T extends any[]> =
  T extends [infer H, ...any[]] ? H : never;
type H = Head<[string, number, boolean]>; // string

// Tail — tout sauf le premier élément
type Tail<T extends any[]> =
  T extends [any, ...infer R] ? R : [];
type T = Tail<[string, number, boolean]>; // [number, boolean]

// DeepFlatten — aplatir des tableaux imbriqués
type DeepFlatten<T> =
  T extends (infer U)[]
    ? U extends any[] ? DeepFlatten<U> : U
    : T;
type F = DeepFlatten<[string, [number, [boolean]]]>;
// string | number | boolean

// Split — parser une chaîne en tuple de strings
type Split<S extends string, D extends string> =
  S extends `${infer Head}${D}${infer Tail}`
    ? [Head, ...Split<Tail, D>]
    : [S];
type P = Split<"a.b.c.d", ".">; // ["a", "b", "c", "d"]

// ── Pattern Zod — Infer le type depuis le schéma ─────────
// La vraie implémentation dans le code source de Zod :
type ZodInfer<S extends ZodType<any>> =
  S extends ZodType<infer T> ? T : never;
// Vous connaissez déjà ce pattern depuis notre MiniZod ✓

// ── Pattern tRPC — inférer les inputs/outputs de procédures ─
type inferProcedureInput<T> =
  T extends { _def: { inputs: (infer In)[] } }
    ? In
    : never;
// Permet au client tRPC de connaître exactement ce qu'une
// procédure attend, sans aucun code partagé manuellement.

// ── Pattern Prisma — type de retour de findMany ───────────
type PrismaFindResult<Model, Args> =
  Args extends { select: infer S }
    ? { [K in keyof S & keyof Model]: Model[K] }
    : Model;
// Si select est fourni → retourner seulement ces champs
// Sinon → retourner le modèle complet

// ── Votre propre Awaited from scratch ────────────────────
// Voici comment TypeScript implémente Awaited internalement :
type MyAwaited<T> =
  T extends { then(onfulfilled: (infer F) => any): any }
    ? F extends (value: infer V) => any
      ? MyAwaited<V>
      : never
    : T;
// Détecte .then() (pas forcément une Promise) → supporte thenable

// Utilitaire générique pour créer des Branded Types
type Brand<T, B> = T & { readonly __brand: B };

type UserId  = Brand<string, "UserId">;
type OrderId = Brand<string, "OrderId">;
type Email   = Brand<string, "Email">;

// Constructeurs — seul point d'entrée
const userId  = (s: string): UserId  => s as UserId;
const orderId = (s: string): OrderId => s as OrderId;

function getOrder(uid: UserId, oid: OrderId): void {}

const uid = userId("user-123");
const oid = orderId("order-456");
getOrder(uid, oid);  // ✅
getOrder(oid, uid);  // ❌ OrderId pas assignable à UserId !

// Builder Pattern — type s'accumule au fil des appels
class QueryBuilder<T, S extends Partial<T> = {}> {
  select<K extends keyof T>(...keys: K[]):
    QueryBuilder<T, S & Pick<T, K>> { return this as any; }
  where(cond: string): this { return this; }
  build(): S[] { return [] as any; }
}

type User = { id: number; name: string; email: string };
const results = new QueryBuilder<User>()
  .select("id", "name")
  .where("role = 'admin'")
  .build();  // { id: number; name: string }[] ✓

// Branded Types avec validation runtime intégrée
type Brand<T, B> = T & { readonly __brand: B };

type Email           = Brand<string, "Email">;
type PositiveInt     = Brand<number, "PositiveInt">;
type NonEmptyString = Brand<string, "NonEmptyString">;

// Parse functions — valident ET brandent en une étape
function parseEmail(s: string): Email {
  if (!/^[^@]+@[^@]+\.[^@]+$/.test(s))
    throw new Error(`Email invalide : ${s}`);
  return s as Email; // ✓ validé → branded
}

function parsePositiveInt(n: number): PositiveInt {
  if (!Number.isInteger(n) || n <= 0)
    throw new Error(`Doit être un entier positif : ${n}`);
  return n as PositiveInt;
}

// Le domaine métier n'accepte QUE des types validés
interface UserService {
  createUser(email: Email, age: PositiveInt): Promise<User>;
}

// À la frontière (controller/API) : valider et brander
async function createUserHandler(body: { email: string; age: number }) {
  const email = parseEmail(body.email);     // Valide et brande
  const age   = parsePositiveInt(body.age); // Valide et brande
  return userService.createUser(email, age);  // ✅ types garantis
  // userService.createUser("bad", -1) ❌ Compilation error !
}

// ── Types fondamentaux ───────────────────────────
type VResult<T> =
  | { success: true;  data: T         }
  | { success: false; errors: string[] };

abstract class Schema<T> {
  abstract parse(val: unknown): VResult<T>;
  declare readonly _type: T; // fantôme pour encoder T
}

// Infer — extraire T depuis Schema<T>
type Infer<S extends Schema<any>> = S["_type"];

// ── Validateurs primitifs ─────────────────────────
class StringSchema extends Schema<string> {
  private minLen?: number;
  private pattern?: RegExp;

  min(n: number)   { this.minLen = n; return this; }
  regex(re: RegExp) { this.pattern = re; return this; }

  parse(val: unknown): VResult<string> {
    const e: string[] = [];
    if (typeof val !== "string") e.push("Expected string");
    else {
      if (this.minLen && val.length < this.minLen)
        e.push(`Min length: ${this.minLen}`);
      if (this.pattern && !this.pattern.test(val))
        e.push(`Pattern mismatch`);
    }
    return e.length
      ? { success: false, errors: e }
      : { success: true,  data: val as string };
  }
}

class NumberSchema extends Schema<number> {
  parse(val: unknown): VResult<number> {
    return typeof val === "number"
      ? { success: true,  data: val }
      : { success: false, errors: ["Expected number"] };
  }
}

// ── ObjectSchema — Mapped Type + infer ───────────
type Shape        = Record<string, Schema<any>>;
type ShapeToType<S extends Shape> =
  { [K in keyof S]: Infer<S[K]> };

class ObjectSchema<S extends Shape>
  extends Schema<ShapeToType<S>> {
  constructor(private shape: S) { super(); }

  parse(val: unknown): VResult<ShapeToType<S>> {
    if (typeof val !== "object" || val === null)
      return { success: false, errors: ["Expected object"] };
    const result: any = {}, errs: string[] = [];
    for (const key in this.shape) {
      const r = this.shape[key].parse((val as any)[key]);
      if (!r.success) errs.push(...r.errors.map(e => `${key}: ${e}`));
      else result[key] = r.data;
    }
    return errs.length
      ? { success: false, errors: errs }
      : { success: true,  data: result };
  }
}

// ── API publique ──────────────────────────────────
const z = {
  string: () => new StringSchema(),
  number: () => new NumberSchema(),
  object: <S extends Shape>(s: S) => new ObjectSchema(s),
};

// ── Utilisation ───────────────────────────────────
const UserSchema = z.object({
  name:  z.string().min(2),
  age:   z.number(),
  email: z.string().regex(/^[^@]+@[^@]+$/),
});

// Type TypeScript inféré depuis le schéma !
type User = Infer<typeof UserSchema>;
// { name: string; age: number; email: string }

const r = UserSchema.parse({ name: "Alice", age: 28, email: "a@b.com" });
if (r.success) {
  const user: User = r.data; // ✅ typé User
}