// 순수하게 ORM만 쓴 코드 — 겉보기엔 깔끔함
class OrderService {
  async getOrdersWithDetails(userId: string) {
    // ORM의 추상화: "DB? 몰라도 됨. 그냥 객체처럼 써"
    const orders = await this.orderRepo.find({
      where: { userId },
      relations: ["items", "items.product"],
    });
    return orders;
  }
}
// 실행되는 SQL:
// SELECT * FROM orders WHERE user_id = '...'
// SELECT * FROM order_items WHERE order_id IN (...)
// SELECT * FROM products WHERE id IN (...)
// → 3번의 쿼리. 주문이 1000개면? 여전히 3번 (다행히 IN절)

// 성능 문제 발생 → ORM 추상화를 뚫고 SQL 지식이 필요해짐
class OrderService {
  async getOrdersWithDetails(userId: string) {
    // ORM이 생성하는 SQL이 비효율적 → 직접 쿼리 작성
    const orders = await this.orderRepo
      .createQueryBuilder("order")
      .leftJoinAndSelect("order.items", "item")
      .leftJoinAndSelect("item.product", "product")
      .where("order.userId = :userId", { userId })
      .addSelect("SUM(item.quantity * item.price)", "order_total")
      .groupBy("order.id")
      .orderBy("order.createdAt", "DESC")
      .limit(50)
      .cache(60000)  // 1분 캐시 — 이것도 알아야 함
      .getMany();

    return orders;
  }
}
// 이 시점에서 개발자가 알아야 하는 것:
// - SQL JOIN 종류와 성능 차이
// - 인덱스 설계
// - 쿼리 실행 계획 (EXPLAIN)
// - 커넥션 풀 관리
// - N+1 문제와 Eager/Lazy Loading
// → ORM이 추상화하겠다던 것들을 전부 알아야 함

// 추상화 역전 예시 1: 프레임워크가 저수준 접근을 막음

// Next.js에서 HTTP 헤더의 raw bytes에 접근하고 싶은데,
// Request 객체가 이미 파싱된 형태로만 제공됨
export async function POST(request: Request) {
  // 필요한 것: raw request body의 바이트 단위 처리
  // (예: webhook signature 검증에 필요)

  // 하지만 Request.json()은 이미 파싱해버림
  // Request.text()는 문자열로 변환해버림

  // 추상화 역전: 고수준 API로 저수준 작업을 우회
  const text = await request.text();
  const rawBytes = new TextEncoder().encode(text);
  // ⚠️ 원본과 다를 수 있음! encoding 차이, BOM 등

  const signature = request.headers.get("x-webhook-signature");
  const isValid = verifySignature(rawBytes, signature);
  // 원본 raw bytes가 아니라 text → bytes 변환이라 서명 불일치 가능
}

// 추상화 역전 예시 2: ORM이 raw SQL을 숨김

// 필요한 것: PostgreSQL의 UPSERT (ON CONFLICT DO UPDATE)
// ORM이 이 기능을 지원하지 않음

class ProductRepository {
  // 추상화 역전: ORM의 고수준 API로 UPSERT를 흉내냄
  async upsertProduct(product: Product): Promise<void> {
    const existing = await this.repo.findOne({
      where: { sku: product.sku }
    });

    if (existing) {
      // 별도 조회 + 업데이트 = 2번의 DB 호출
      await this.repo.update(existing.id, product);
    } else {
      await this.repo.save(product);
    }
    // 문제점:
    // 1. 조회와 저장 사이에 다른 트랜잭션이 끼어들 수 있음 (race condition)
    // 2. 2번의 쿼리 vs 원래 1번이면 되는 UPSERT
    // 3. DB가 제공하는 원자성을 활용 못함
  }

  // 진짜 해결: raw SQL 사용 (추상화를 뚫는 게 차라리 나음)
  async upsertProductCorrectly(product: Product): Promise<void> {
    await this.dataSource.query(`
      INSERT INTO products (sku, name, price)
      VALUES ($1, $2, $3)
      ON CONFLICT (sku) DO UPDATE
      SET name = EXCLUDED.name, price = EXCLUDED.price
    `, [product.sku, product.name, product.price]);
  }
}

// 추상화 역전 예시 3: Set이 필요한데 Array로 구현

// 상황: 중복 없는 컬렉션에서 특정 요소의 존재 여부를 빠르게 확인하고 싶음
// 문제: 코드베이스 전체가 Array 기반이라 Set으로 전환이 어려움

class TagManager {
  private tags: string[] = [];  // Set이어야 하는데 Array

  // O(n) — Set이면 O(1)
  hasTag(tag: string): boolean {
    return this.tags.indexOf(tag) !== -1;
  }

  // O(n) — 중복 체크해야 하니까
  addTag(tag: string): void {
    if (!this.hasTag(tag)) {  // indexOf 한 번
      this.tags.push(tag);
    }
  }

  // O(n) — splice가 필요
  removeTag(tag: string): void {
    const idx = this.tags.indexOf(tag);  // indexOf 한 번
    if (idx !== -1) {
      this.tags.splice(idx, 1);  // 뒤의 요소 전부 이동
    }
  }

  // 이 모든 메서드가 O(1)이면 되는데, Array의 "추상화"가
  // 해시 테이블의 저수준 성능을 가림
}

// 올바른 해결
class TagManager {
  private tags: Set<string> = new Set();

  hasTag(tag: string): boolean { return this.tags.has(tag); }      // O(1)
  addTag(tag: string): void { this.tags.add(tag); }                // O(1)
  removeTag(tag: string): void { this.tags.delete(tag); }          // O(1)
}

// 요청 컨텍스트 객체 풀 — 초기화 안 한 예시
class RequestContext {
  userId: string = "";
  role: string = "guest";
  permissions: string[] = [];
  sessionData: Record<string, any> = {};
  requestId: string = "";
}

class RequestContextPool {
  private pool: RequestContext[] = [];
  private maxSize = 100;

  acquire(): RequestContext {
    // 풀에 있으면 꺼내서 반환
    if (this.pool.length > 0) {
      return this.pool.pop()!;  // 🚨 초기화 없이 반환!
    }
    return new RequestContext();
  }

  release(ctx: RequestContext): void {
    if (this.pool.length < this.maxSize) {
      this.pool.push(ctx);  // 🚨 초기화 없이 풀에 반환!
    }
  }
}

// 사용 시나리오
const pool = new RequestContextPool();

// 요청 1: 관리자 로그인
async function handleAdminRequest() {
  const ctx = pool.acquire();
  ctx.userId = "admin-001";
  ctx.role = "admin";
  ctx.permissions = ["read", "write", "delete", "admin"];
  ctx.sessionData = { lastAccess: Date.now(), secretKey: "abc123" };

  await processRequest(ctx);
  pool.release(ctx);  // 관리자 데이터가 담긴 채로 반환
}

// 요청 2: 일반 사용자 — 관리자의 컨텍스트를 받음!
async function handleUserRequest() {
  const ctx = pool.acquire();  // 🚨 관리자의 데이터가 남아있음!

  // ctx.userId = "admin-001"   ← 이전 사용자의 ID
  // ctx.role = "admin"         ← 관리자 권한!
  // ctx.permissions = ["read", "write", "delete", "admin"]
  // ctx.sessionData = { secretKey: "abc123" }  ← 민감 데이터 노출!

  ctx.userId = "user-042";  // 유저 ID는 덮어썼지만...
  // role, permissions, sessionData는 안 바꿈 — 관리자 권한 유지!

  if (ctx.permissions.includes("admin")) {
    // 일반 사용자가 관리자 기능에 접근 가능!!
    await deleteAllUsers();  // 보안 사고
  }
}

class RequestContext {
  userId: string = "";
  role: string = "guest";
  permissions: string[] = [];
  sessionData: Record<string, any> = {};
  requestId: string = "";

  // 핵심: 재사용 전 초기화 메서드
  reset(): void {
    this.userId = "";
    this.role = "guest";
    this.permissions = [];
    this.sessionData = {};
    this.requestId = "";
  }
}

class SafeRequestContextPool {
  private pool: RequestContext[] = [];
  private maxSize = 100;

  acquire(): RequestContext {
    if (this.pool.length > 0) {
      const ctx = this.pool.pop()!;
      ctx.reset();  // 반드시 초기화 후 반환
      return ctx;
    }
    return new RequestContext();
  }

  release(ctx: RequestContext): void {
    ctx.reset();  // 반환 시에도 초기화 (이중 안전장치)
    if (this.pool.length < this.maxSize) {
      this.pool.push(ctx);
    }
  }
}

// 불변 컨텍스트 — 오염 자체가 불가능
interface RequestContext {
  readonly userId: string;
  readonly role: string;
  readonly permissions: readonly string[];
  readonly requestId: string;
}

// 매번 새로 생성 (Object.freeze로 불변 보장)
function createContext(userId: string, role: string, permissions: string[]): RequestContext {
  return Object.freeze({
    userId,
    role,
    permissions: Object.freeze([...permissions]),
    requestId: crypto.randomUUID(),
  });
}

// 이전 컨텍스트의 데이터가 절대 다음에 영향을 줄 수 없음