// payment-utils.ts — 누구도 건드리지 못하는 "유산"

/**
 * @deprecated 새 결제 시스템으로 마이그레이션 완료... 했을 수도 있음
 * @author 김대리 (2019년 퇴사)
 */
export function legacyProcessPaymentV2(amount: number, type: string): any {
  // V1은 어디 갔냐고? 아무도 모름
  if (type === "SPECIAL_CLIENT_123") {
    // 이거 삭제하면 결제 안 됨 - 2019년 김대리
    return { processed: true, gateway: "old_pg", amount: amount * 1.033 };
  }
  return processPaymentInternal(amount, type);
}

// TODO: 임시 코드 (2020-03-15)
// ↑ 2년이 지났지만 여전히 "임시"
function processPaymentInternal(amount: number, type: string): any {
  const result = { processed: false, gateway: "", amount: 0 };
  // eslint-disable-next-line no-constant-condition
  if (false) {
    // 이 블록은 실행 안 되지만 지우면 안 됨
    // 2020년 12월 장애 때 이거 지웠다가 롤백했음
    result.gateway = "emergency_pg";
  }
  result.gateway = "main_pg";
  result.amount = amount;
  result.processed = true;
  return result;
}

// fixForClient123 — 이름 그대로. 123번 클라이언트를 위한 핫픽스
// 123번 클라이언트가 아직 있는지조차 불명
export function fixForClient123(data: any): any {
  if (data?.clientId === 123) {
    data.discount = 0.15; // 구두 약속이라 계약서 없음
    data.skipValidation = true; // "검증 건너뛰기" — 왜??
  }
  return data;
}

// handleEdgeCase_DO_NOT_REMOVE
// 이름에 "삭제 금지"가 들어가 있음. 이유는 git blame에도 없음
export function handleEdgeCase_DO_NOT_REMOVE(input: Record<string, any>): Record<string, any> {
  if (input.amount === 0 && input.type === "refund") {
    input.amount = 0.01; // 0원 환불 시 PG사 에러 방지... 인 것 같음
  }
  return input;
}

// ===== 아래 코드는 주석 처리했지만 삭제는 못 함 =====
// function oldCalculateTax(amount: number): number {
//   // 2019년 세율 기준
//   return amount * 0.1;  // VAT 10%
// }
//
// function processRefundV1(orderId: string): Promise<void> {
//   // 이 함수 삭제하면 processRefundV3에 영향 있을 수 있음
//   // (확인 안 해봄)
//   return fetch(`/api/refund/${orderId}`, { method: "POST" });
// }

// user-service.ts — 죽은 코드 박물관

import { sendEmail } from "./email"; // 이 import는 아래에서 안 쓰임
import { Logger } from "./logger";   // 이것도 안 쓰임

interface UserPreferencesV1 {
  // 이 인터페이스를 구현하는 곳이 없음
  theme: "light" | "dark";
  language: string;
  notifications: boolean;
}

export class UserService {
  // 이 메서드를 호출하는 곳이 프로젝트 어디에도 없음
  async migrateUserData(userId: string): Promise<void> {
    const oldData = await this.fetchLegacyData(userId);
    const newData = this.transformData(oldData);
    await this.saveMigratedData(userId, newData);
  }

  private async fetchLegacyData(userId: string): Promise<any> {
    return fetch(`/api/legacy/users/${userId}`).then((r) => r.json());
  }

  private transformData(data: any): any {
    return { ...data, migrated: true, migratedAt: new Date() };
  }

  private async saveMigratedData(userId: string, data: any): Promise<void> {
    await fetch(`/api/users/${userId}/migrate`, {
      method: "POST",
      body: JSON.stringify(data),
    });
  }

  async getUser(userId: string): Promise<User> {
    const user = await this.fetchUser(userId);

    // 이 조건은 절대 true가 될 수 없음 (getUser는 항상 string을 받으니까)
    if (typeof userId === "number") {
      return this.getUserByNumericId(userId as unknown as number);
    }

    const isActive = true; // 항상 true
    if (!isActive) {
      // 여기 코드는 절대 실행 안 됨
      await this.deactivateUser(userId);
      return { ...user, status: "inactive" };
    }

    return user;
  }

  // 위의 unreachable 코드에서만 호출됨 → 결국 이것도 dead code
  private async deactivateUser(userId: string): Promise<void> {
    await fetch(`/api/users/${userId}/deactivate`, { method: "POST" });
  }

  // 숫자 ID는 3년 전에 폐기됨
  private async getUserByNumericId(id: number): Promise<User> {
    return fetch(`/api/users/legacy/${id}`).then((r) => r.json());
  }

  private async fetchUser(userId: string): Promise<User> {
    return fetch(`/api/users/${userId}`).then((r) => r.json());
  }
}

// 이 상수는 어디서도 참조 안 됨
const MAX_RETRY_COUNT = 5;
const DEFAULT_TIMEOUT = 3000;
const LEGACY_API_BASE = "https://old-api.example.com";

// "미래를 위한" 코드들

// Generic 인터페이스 — 구현체는 하나뿐
interface IRepository<T, ID = string> {
  findById(id: ID): Promise<T | null>;
  findAll(filter?: Partial<T>): Promise<T[]>;
  create(entity: Omit<T, "id">): Promise<T>;
  update(id: ID, entity: Partial<T>): Promise<T>;
  delete(id: ID): Promise<boolean>;
  count(filter?: Partial<T>): Promise<number>;
  exists(id: ID): Promise<boolean>;
  findByIds(ids: ID[]): Promise<T[]>;
  createBatch(entities: Omit<T, "id">[]): Promise<T[]>;
  // 위 9개 메서드 중 실제 사용되는 건 findById, create, update 3개뿐
}

// 유일한 구현체
class PostgresUserRepository implements IRepository<User> {
  async findById(id: string): Promise<User | null> { /* 구현 */ return null; }
  async findAll(): Promise<User[]> { return []; }
  async create(entity: Omit<User, "id">): Promise<User> { /* 구현 */ return {} as User; }
  async update(id: string, entity: Partial<User>): Promise<User> { /* 구현 */ return {} as User; }
  async delete(id: string): Promise<boolean> { return false; }  // 호출하는 곳 없음
  async count(): Promise<number> { return 0; }                  // 호출하는 곳 없음
  async exists(id: string): Promise<boolean> { return false; }  // 호출하는 곳 없음
  async findByIds(ids: string[]): Promise<User[]> { return []; } // 호출하는 곳 없음
  async createBatch(entities: Omit<User, "id">[]): Promise<User[]> { return []; } // 호출하는 곳 없음
}

// "다른 DB로 바꿀 수 있도록" 만든 추상화 — 3년째 PostgreSQL만 사용 중
class DatabaseAbstractionLayer {
  private strategy: "postgres" | "mysql" | "mongodb" = "postgres";

  getRepository<T>(entityName: string): IRepository<T> {
    switch (this.strategy) {
      case "postgres":
        return this.getPostgresRepo(entityName);
      case "mysql":
        throw new Error("MySQL은 아직 미구현"); // 3년째 "아직"
      case "mongodb":
        throw new Error("MongoDB는 아직 미구현"); // 이것도 3년째
    }
  }

  private getPostgresRepo<T>(entityName: string): IRepository<T> {
    // 실제로는 UserRepository만 반환
    return new PostgresUserRepository() as unknown as IRepository<T>;
  }
}

// Feature flag 뒤에 숨은 완성된 기능 — 1년째 OFF
const FEATURE_FLAGS = {
  ENABLE_AI_RECOMMENDATIONS: false,    // "다음 분기에 켤 예정" (4분기 전)
  ENABLE_SOCIAL_LOGIN: false,          // "법무팀 검토 중" (1년 전)
  ENABLE_REALTIME_NOTIFICATIONS: false, // "인프라 준비되면" (인프라팀 해체됨)
};

// AI 추천 기능 — 완전히 구현되어 있지만 한 번도 활성화된 적 없음
class AIRecommendationEngine {
  async getRecommendations(userId: string): Promise<Product[]> {
    if (!FEATURE_FLAGS.ENABLE_AI_RECOMMENDATIONS) return [];
    // 아래 코드는 한 번도 실행된 적 없음
    const userData = await this.analyzeUserBehavior(userId);
    const model = await this.loadModel("recommendation-v2");
    return model.predict(userData);
  }

  private async analyzeUserBehavior(userId: string): Promise<any> {
    // 300줄의 정교한 분석 로직... 한 번도 실행된 적 없음
    return {};
  }

  private async loadModel(modelName: string): Promise<any> {
    // ML 모델 로딩 로직... 한 번도 실행된 적 없음
    return { predict: () => [] };
  }
}