// "만능" 데이터 처리 인터페이스
interface DataProcessor {
  // 읽기
  readFromFile(path: string): Promise<Data>;
  readFromURL(url: string): Promise<Data>;
  readFromStream(stream: ReadableStream): Promise<Data>;
  readFromBuffer(buffer: Buffer): Promise<Data>;
  readFromString(str: string): Data;

  // 변환
  toJSON(): string;
  toXML(): string;
  toCSV(): string;
  toYAML(): string;
  toProtobuf(): Buffer;
  toMsgPack(): Buffer;

  // 검증
  validate(schema: Schema): boolean;
  validateStrict(schema: Schema): ValidationResult;
  sanitize(rules: SanitizeRules): Data;

  // 암호화
  encrypt(key: string, algorithm?: string): Buffer;
  decrypt(key: string, algorithm?: string): Data;
  hash(algorithm?: string): string;
  sign(privateKey: string): string;

  // 압축
  compress(format?: "gzip" | "brotli" | "zstd"): Buffer;
  decompress(format?: "gzip" | "brotli" | "zstd"): Data;

  // 전송
  sendToAPI(endpoint: string, options?: RequestOptions): Promise<Response>;
  sendToQueue(queueName: string): Promise<void>;
  sendToWebSocket(ws: WebSocket): void;

  // 기타
  clone(): Data;
  diff(other: Data): DiffResult;
  merge(other: Data): Data;
  transform(fn: (data: Data) => Data): Data;
}

// 폴터가이스트: OrderProcessor
class OrderProcessor {
  // 자체 상태 없음. 필드도 없음.
  processOrder(order: Order): ProcessResult {
    const validator = new OrderValidator();
    const isValid = validator.validate(order); // 다른 클래스에 위임

    if (!isValid) return { success: false, error: "Invalid order" };

    const calculator = new PriceCalculator();
    const total = calculator.calculate(order.items); // 또 다른 클래스에 위임

    const repository = new OrderRepository();
    repository.save({ ...order, total }); // 또 위임

    return { success: true };
  }
}

// 사용하는 쪽
function handleCheckout(order: Order) {
  const processor = new OrderProcessor(); // 생성!
  const result = processor.processOrder(order); // 호출!
  // processor는 이제 쓸모없음. GC 대상.
}

// 폴터가이스트 제거: 그냥 함수로
async function processOrder(order: Order): Promise<ProcessResult> {
  if (!validateOrder(order)) return { success: false, error: "Invalid" };
  const total = calculateTotal(order.items);
  await saveOrder({ ...order, total });
  return { success: true };
}

// ❌ "문자열 연결이 느리니까" 최적화
function buildQuery_bad(conditions: string[]): string {
  // "+" 연산자가 느리다며 배열로 조합
  const parts: string[] = [];
  parts[parts.length] = "SELECT * FROM users WHERE 1=1"; // push 대신 직접 인덱싱 (더 빠르다고?)
  for (let i = 0; i < conditions.length; i++) { // for...of가 느리다며 인덱스 루프
    parts[parts.length] = " AND ";
    parts[parts.length] = conditions[i];
  }
  return parts.join(""); // 마지막에 join
}

// ❌ "비트 연산이 더 빠르니까" 최적화
function isEven_bad(n: number): boolean {
  return (n & 1) === 0; // n % 2 === 0 대신 비트 연산
}

function divideByTwo_bad(n: number): number {
  return n >> 1; // n / 2 대신 비트 시프트
}

// ❌ "혹시 느릴 수 있으니까" 모든 것을 캐싱
class UserService_bad {
  private cache = new Map<string, User>();
  private cacheTimestamps = new Map<string, number>();
  private readonly CACHE_TTL = 5 * 60 * 1000;

  async getUser(id: string): Promise<User> {
    const cached = this.cache.get(id);
    const timestamp = this.cacheTimestamps.get(id);
    if (cached && timestamp && Date.now() - timestamp < this.CACHE_TTL) {
      return cached;
    }
    const user = await this.db.findUser(id);
    this.cache.set(id, user);
    this.cacheTimestamps.set(id, Date.now());
    return user;
  }
  // getUser가 1초에 1번 호출되는 관리자 페이지인데
  // 이 캐싱 로직이 필요했을까?
}

// ✅ 먼저 읽기 쉽게 작성하고, 프로파일링 후 필요한 곳만 최적화
function buildQuery(conditions: string[]): string {
  const base = "SELECT * FROM users WHERE 1=1";
  return conditions.reduce((q, c) => `${q} AND ${c}`, base);
}

function isEven(n: number): boolean {
  return n % 2 === 0; // 의도가 명확함
}

// 캐싱이 진짜 필요한지는 프로파일링으로 확인한 후에 추가
class UserService {
  async getUser(id: string): Promise<User> {
    return this.db.findUser(id); // 일단 단순하게
  }
}

// 상황: 유저 등록 폼과 상품 등록 폼이 비슷해 보임
// "둘 다 폼이니까 공통 컴포넌트로 만들자!"

// ❌ 성급한 추상화
interface FormConfig {
  fields: Array<{
    name: string;
    type: "text" | "number" | "email" | "select" | "file" | "rich-text";
    label: string;
    required?: boolean;
    validation?: (value: any) => string | null;
    options?: string[];           // select용
    accept?: string;              // file용
    maxLength?: number;           // text용
    min?: number; max?: number;   // number용
    placeholder?: string;
    dependsOn?: string;           // 조건부 렌더링
    customRenderer?: () => JSX.Element; // 커스텀 렌더링이 필요하면...
  }>;
  onSubmit: (data: Record<string, any>) => Promise<void>;
  layout?: "vertical" | "horizontal" | "grid";
  showReset?: boolean;
  submitLabel?: string;
}

function GenericForm({ config }: { config: FormConfig }) {
  // 200줄짜리 분기 로직...
  // if (field.type === "select") ... else if (field.type === "file") ...
  // if (field.dependsOn) ... if (field.customRenderer) ...
}

// ✅ 그냥 각각 만들면 됨
function UserRegistrationForm() {
  // 유저 등록에 필요한 것만. 30줄.
  // 나중에 이메일 인증이 필요하면 여기에만 추가.
}

function ProductForm() {
  // 상품 등록에 필요한 것만. 40줄.
  // 나중에 이미지 업로드가 필요하면 여기에만 추가.
}

// 진짜 공통인 것만 추출 (예: 입력 필드 컴포넌트)
function TextField({ label, value, onChange, error }: TextFieldProps) {
  // 이건 진짜 공통이다. 10줄.
}