Generic và Utility Types — viết một lần, dùng cho mọi type

// Cách 1 — quá hẹp, mỗi type 1 hàm
function identityNumber(x: number): number { return x; }
function identityString(x: string): string { return x; }

// Cách 2 — any, mất type
function identity(x: any): any { return x; }
const r = identity(5);   // r: any — không gợi ý gì cả
r.toUpperCase();         // 💥 runtime error, TS không catch

function identity<T>(x: T): T {
  return x;
}

// Cách 1 — gọi explicit, chỉ định T
const a = identity<number>(5);     // a: number
const b = identity<string>("hi"); // b: string

// Cách 2 — để TS infer (thường dùng)
const c = identity(5);            // c: number — T inferred = number
const d = identity("hi");         // d: string
const e = identity([1, 2, 3]);    // e: number[]

function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}

const p1 = pair(1, "x");        // p1: [number, string]
const p2 = pair(true, [1, 2]);  // p2: [boolean, number[]]

// Ví dụ thực tế — zip 2 array
function zip<A, B>(as: A[], bs: B[]): [A, B][] {
  const n = Math.min(as.length, bs.length);
  const out: [A, B][] = [];
  for (let i = 0; i < n; i++) out.push([as[i], bs[i]]);
  return out;
}

const z = zip([1, 2], ["a", "b"]);  // z: [number, string][]

function map<T, U>(arr: T[], fn: (x: T) => U): U[] {
  const out: U[] = [];
  for (const x of arr) out.push(fn(x));
  return out;
}

const lengths = map(["hi", "world"], s => s.length);
// lengths: number[]   ← TS infer T=string, U=number

// Không constraint — sai vì không phải mọi T có .length
function len<T>(x: T): number {
  return x.length;  // ❌ Property 'length' does not exist on type 'T'
}

// Có constraint — T phải có .length
function len<T extends { length: number }>(x: T): number {
  return x.length;
}

len("hello");          // OK — string có length
len([1, 2, 3]);        // OK — array có length
len({ length: 10, x: 1 }); // OK — object có length
len(42);               // ❌ number không có length

function getProp<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const user = { id: 1, name: "An", active: true };

const id   = getProp(user, "id");     // id: number
const name = getProp(user, "name");   // name: string
const act  = getProp(user, "active"); // act: boolean

getProp(user, "email");
// ❌ Argument of type '"email"' is not assignable to parameter of type 'keyof typeof user'

function createArray<T = string>(): T[] {
  return [];
}

const a = createArray();            // a: string[]   (default)
const b = createArray<number>();    // b: number[]

// Combo: default + constraint
interface ApiResponse<T extends object = {}> {
  status: number;
  data: T;
}

const r1: ApiResponse = { status: 200, data: {} };
const r2: ApiResponse<{ id: number }> = { status: 200, data: { id: 1 } };

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

  push(x: T): void {
    this.items.push(x);
  }

  pop(): T | undefined {
    return this.items.pop();
  }

  peek(): T | undefined {
    return this.items[this.items.length - 1];
  }

  get size(): number {
    return this.items.length;
  }
}

const numbers = new Stack<number>();
numbers.push(1);
numbers.push(2);
const top = numbers.pop();  // top: number | undefined

const strs = new Stack<string>();
strs.push("hello");
strs.push(42);  // ❌ number không gán vào string

// Cách 1 — interface
interface Box<T> {
  value: T;
}

// Cách 2 — type alias (tương đương)
type Box2<T> = { value: T };

const b1: Box<number> = { value: 42 };
const b2: Box<string> = { value: "hi" };

// Generic interface trong API — pattern phổ biến
interface Result<T, E = Error> {
  ok: boolean;
  data?: T;
  error?: E;
}

const success: Result<number> = { ok: true, data: 42 };
const fail: Result<number, string> = { ok: false, error: "timeout" };

// Interface mô tả function generic
interface Mapper {
  <T, U>(arr: T[], fn: (x: T) => U): U[];
}

const myMap: Mapper = (arr, fn) => arr.map(fn);
myMap([1, 2], n => n * 2);  // number[]

interface User {
  id: number;
  name: string;
  email: string;
  active: boolean;
}

// updateUser nhận subset of User — chỉ field nào muốn đổi
function updateUser(id: number, patch: Partial<User>): User {
  // ... merge với user hiện tại
  return { id, name: "x", email: "x", active: true, ...patch };
}

updateUser(1, { name: "An" });               // OK
updateUser(1, { email: "a@b", active: false }); // OK
updateUser(1, {});                              // OK (rỗng cũng được)

interface PartialConfig {
  theme?: string;
  lang?: string;
  debug?: boolean;
}

type FullConfig = Required<PartialConfig>;
// = { theme: string; lang: string; debug: boolean }   ← bỏ tất cả ?

function applyConfig(c: FullConfig) {
  // c.theme đảm bảo có, không phải undefined
}

interface Point { x: number; y: number; }

const p: Readonly<Point> = { x: 1, y: 2 };
p.x = 5;  // ❌ Cannot assign to 'x' because it is a read-only property

interface User {
  id: number;
  name: string;
  email: string;
  password: string;
  createdAt: Date;
}

// Trả API: không lộ password
type UserResponse = Omit<User, "password">;
// = { id: number; name: string; email: string; createdAt: Date }

// Item trong list — chỉ cần id + name
type UserListItem = Pick<User, "id" | "name">;
// = { id: number; name: string }

// Form đăng nhập — chỉ email + password
type LoginForm = Pick<User, "email" | "password">;

// Object có chính xác 3 key Role → number (count user)
type Role = "admin" | "user" | "guest";

type RoleCount = Record<Role, number>;
// = { admin: number; user: number; guest: number }

const counts: RoleCount = {
  admin: 2,
  user: 100,
  guest: 42,
};

counts.user;   // number
counts.other;  // ❌ Property 'other' does not exist

// String key bất kỳ — tương đương index signature
type Dict<V> = Record<string, V>;
// = { [key: string]: V }

const ages: Dict<number> = { an: 22, binh: 23 };

type Status = "pending" | "success" | "error" | "cancelled";

// Bỏ "cancelled"
type ActiveStatus = Exclude<Status, "cancelled">;
// = "pending" | "success" | "error"

// Chỉ giữ "success" và "error"
type DoneStatus = Extract<Status, "success" | "error">;
// = "success" | "error"

// Bỏ null/undefined
type MaybeName = string | null | undefined;
type Name = NonNullable<MaybeName>;  // = string

// Áp dụng trong function — narrow sau check
function trim(s: string | null): string {
  if (s === null) return "";
  const v: NonNullable<typeof s> = s;  // v: string
  return v.trim();
}

function createUser(name: string, age: number) {
  return { id: Date.now(), name, age, active: true };
}

// Lấy return type — không cần định nghĩa lại
type User = ReturnType<typeof createUser>;
// = { id: number; name: string; age: number; active: boolean }

// Lấy tuple param
type Args = Parameters<typeof createUser>;
// = [name: string, age: number]

// Lấy param đầu
type FirstArg = Parameters<typeof createUser>[0];  // = string

async function fetchUser(): Promise<{ id: number; name: string }> {
  return { id: 1, name: "An" };
}

// ReturnType — chỉ lấy Promise<...>, chưa unwrap
type R = ReturnType<typeof fetchUser>;
// R = Promise<{ id: number; name: string }>

// Awaited — lấy giá trị bên trong Promise
type User = Awaited<R>;
// User = { id: number; name: string }

// Combo phổ biến
type User2 = Awaited<ReturnType<typeof fetchUser>>;

// Awaited đệ quy — unwrap Promise lồng
type A = Awaited<Promise<Promise<number>>>;  // = number

// 1. Nullable — thêm null vào union
type Nullable<T> = T | null;

const name: Nullable<string> = null;       // OK
const name2: Nullable<string> = "hello";   // OK

// 2. Optional — thêm null + undefined
type Maybe<T> = T | null | undefined;

// 3. ValueOf — tương tự keyof nhưng cho value type
type ValueOf<T> = T[keyof T];

interface Color { red: 1; green: 2; blue: 3; }
type ColorValue = ValueOf<Color>;  // = 1 | 2 | 3

// 4. DeepPartial — phiên bản đệ quy của Partial
//    (đầy đủ ở chương 11 — đây là intro)
type DeepPartial<T> = {
  [K in keyof T]?: T[K] extends object
    ? DeepPartial<T[K]>
    : T[K];
};

interface Config {
  ui: { theme: string; lang: string };
  api: { url: string; timeout: number };
}

const p: DeepPartial<Config> = {
  ui: { theme: "dark" },   // thiếu lang — OK vì đã đệ quy
};