SOLID 원칙 적용

class UserProfile {
  private user: { id: string; name: string; email: string };

  constructor(id: string, name: string, email: string) {
    this.user = { id, name, email };
  }

  // 사용자 정보 표시 (UI 관련 책임)
  displayUser(): void {
    console.log(`User ID: ${this.user.id}`);
    console.log(`Name: ${this.user.name}`);
    console.log(`Email: ${this.user.email}`);
  }

  // 사용자 데이터 저장 (데이터 저장 책임)
  saveUserToDatabase(): void {
    console.log(`Saving user ${this.user.name} to database...`);
    // 실제 데이터베이스 로직 (생략)
  }

  // 사용자 이메일 유효성 검사 (유효성 검사 책임)
  isValidEmail(): boolean {
    return this.user.email.includes('@');
  }
}

// 이 클래스는 사용자 정보 표시, 저장, 유효성 검사라는 세 가지 책임을 가집니다.
// 만약 UI가 변경되거나, 데이터베이스 로직이 변경되거나, 유효성 검사 로직이 변경되면
// 이 UserProfile 클래스를 수정해야 합니다.

// 1. 사용자 데이터 모델 (데이터 구조 정의 책임)
interface User {
  id: string;
  name: string;
  email: string;
}

// 2. 사용자 정보 표시 로직 (UI 표시 책임)
class UserView {
  displayUser(user: User): void {
    console.log(`User ID: ${user.id}`);
    console.log(`Name: ${user.name}`);
    console.log(`Email: ${user.email}`);
  }
}

// 3. 사용자 데이터 저장 로직 (데이터 저장 책임)
class UserRepository {
  save(user: User): void {
    console.log(`Saving user ${user.name} to database...`);
    // 실제 데이터베이스 로직
  }
}

// 4. 사용자 데이터 유효성 검사 로직 (유효성 검사 책임)
class UserValidator {
  isValidEmail(email: string): boolean {
    return email.includes('@'); // 기존 예제의 검사 규칙을 그대로 이동
  }

  isValidUser(user: User): boolean {
    return this.isValidEmail(user.email);
  }
}

// 사용 예시
const newUser: User = { id: '123', name: 'Alice', email: '[email protected]' };

const userView = new UserView();
userView.displayUser(newUser);

const userRepository = new UserRepository();
userRepository.save(newUser);

const userValidator = new UserValidator();
if (userValidator.isValidUser(newUser)) {
  console.log("User data is valid.");
}

// 할인율을 계산하는 클래스
class DiscountCalculator {
  calculateDiscount(amount: number, customerType: 'regular' | 'premium' | 'vip'): number {
    if (customerType === 'regular') {
      return amount * 0.05; // 5% 할인
    } else if (customerType === 'premium') {
      return amount * 0.10; // 10% 할인
    } else if (customerType === 'vip') {
      return amount * 0.15; // 15% 할인
    }
    return 0;
  }
}

// 새로운 고객 유형(예: 'gold')이 추가되면 calculateDiscount 메서드를 수정해야 합니다.
// 할인 정책을 추가할 때마다 같은 분기를 수정해야 하는 확장 비용을 보여줍니다.

// 할인 전략을 위한 인터페이스 정의
interface IDiscountStrategy {
  calculate(amount: number): number;
}

// 일반 고객 할인 전략
class RegularDiscountStrategy implements IDiscountStrategy {
  calculate(amount: number): number {
    return amount * 0.05;
  }
}

// 프리미엄 고객 할인 전략
class PremiumDiscountStrategy implements IDiscountStrategy {
  calculate(amount: number): number {
    return amount * 0.10;
  }
}

// VIP 고객 할인 전략
class VipDiscountStrategy implements IDiscountStrategy {
  calculate(amount: number): number {
    return amount * 0.15;
  }
}

// 할인을 적용하는 계산기 클래스 (수정할 필요 없음)
class OrderCalculator {
  calculateTotalPrice(amount: number, discountStrategy: IDiscountStrategy): number {
    const discount = discountStrategy.calculate(amount);
    return amount - discount;
  }
}

// 사용 예시
const orderCalculator = new OrderCalculator();

const regularCustomerPrice = orderCalculator.calculateTotalPrice(1000, new RegularDiscountStrategy());
console.log(`Regular customer price: ${regularCustomerPrice}`); // 950

const premiumCustomerPrice = orderCalculator.calculateTotalPrice(1000, new PremiumDiscountStrategy());
console.log(`Premium customer price: ${premiumCustomerPrice}`); // 900

// 새로운 고객 유형 'Gold' 추가 시
class GoldDiscountStrategy implements IDiscountStrategy {
  calculate(amount: number): number {
    return amount * 0.20; // 20% 할인
  }
}

const goldCustomerPrice = orderCalculator.calculateTotalPrice(1000, new GoldDiscountStrategy());
console.log(`Gold customer price: ${goldCustomerPrice}`); // 800

// OrderCalculator 클래스는 수정 없이 새로운 할인 전략을 '확장'할 수 있습니다.

class Bird {
  fly(): void {
    console.log("I can fly!");
  }
}

class Penguin extends Bird {
  // 펭귄은 날 수 없으므로, fly 메서드를 오버라이드하여 예외를 발생시키거나 빈 동작을 합니다.
  fly(): void {
    throw new Error("Penguins cannot fly!"); // 또는 console.log("Penguins can't fly.");
  }
}

function makeBirdFly(bird: Bird): void {
  bird.fly();
}

const eagle = new Bird();
const penguin = new Penguin();

makeBirdFly(eagle);    // "I can fly!"
makeBirdFly(penguin);  // 런타임 오류 발생: "Penguins cannot fly!"
// makeBirdFly 함수는 Bird 타입의 객체를 기대하지만, Penguin 객체는 예상치 못한 동작을 합니다.

// 비행 능력을 나타내는 인터페이스
interface Flyable {
  fly(): void;
}

// 걷기 능력을 나타내는 인터페이스
interface Walkable {
  walk(): void;
}

// 일반적인 조류
class Bird implements Walkable { // 모든 새가 날 수 있는 것은 아니므로, Flyable을 직접 구현하지 않습니다.
  walk(): void {
    console.log("I can walk.");
  }
}

// 독수리는 날 수 있으므로 Flyable과 Walkable 모두 구현
class Eagle extends Bird implements Flyable {
  fly(): void {
    console.log("Eagle soars through the sky!");
  }
}

// 펭귄은 날 수 없지만 걸을 수 있음
class Penguin extends Bird { // Bird를 상속하여 walk 기능을 가짐
  // fly 메서드를 구현하지 않음 (Flyable 인터페이스를 구현하지 않았으므로 문제가 없음)
}

function makeFlyingAnimalFly(animal: Flyable): void {
  animal.fly();
}

function makeWalkingAnimalWalk(animal: Walkable): void {
  animal.walk();
}

const eagle = new Eagle();
const penguin = new Penguin();

makeWalkingAnimalWalk(eagle); // "I can walk."
makeWalkingAnimalWalk(penguin); // "I can walk."

makeFlyingAnimalFly(eagle); // "Eagle soars through the sky!"
// makeFlyingAnimalFly(penguin); // 컴파일 오류: 'Penguin' 형식은 'Flyable' 형식에 할당될 수 없습니다.
                               // Penguin에는 필요한 fly 멤버가 없으므로
                               // 함수 인자로 전달될 수 없다는 것을 컴파일러가 알려줍니다.

// 너무 큰 단일 인터페이스
interface Worker {
  work(): void;
  eat(): void;
  sleep(): void;
  manageTeam(): void; // 모든 Worker에게 필요하지 않을 수 있는 기능
  code(): void;       // 모든 Worker에게 필요하지 않을 수 있는 기능
  designUI(): void;   // 모든 Worker에게 필요하지 않을 수 있는 기능
}

class JuniorDeveloper implements Worker {
  work(): void { console.log("Junior dev working..."); }
  eat(): void { console.log("Junior dev eating..."); }
  sleep(): void { console.log("Junior dev sleeping..."); }
  manageTeam(): void { /* 필요 없지만 구현해야 함 */ } // 빈 구현 또는 오류
  code(): void { console.log("Junior dev coding..."); }
  designUI(): void { /* 필요 없지만 구현해야 함 */ } // 빈 구현 또는 오류
}

class CEO implements Worker {
  work(): void { console.log("CEO working..."); }
  eat(): void { console.log("CEO eating..."); }
  sleep(): void { console.log("CEO sleeping..."); }
  manageTeam(): void { console.log("CEO managing team..."); }
  code(): void { /* 필요 없지만 구현해야 함 */ } // 빈 구현 또는 오류
  designUI(): void { /* 필요 없지만 구현해야 함 */ } // 빈 구현 또는 오류
}
// JuniorDeveloper나 CEO는 자신이 사용하지 않는 manageTeam, code, designUI 등의 메서드를
// 강제로 구현해야 하므로 ISP를 위반합니다.

// 작은 단위로 분리된 인터페이스들
interface Workable {
  work(): void;
}

interface Eatable {
  eat(): void;
}

interface Sleepable {
  sleep(): void;
}

interface Managable {
  manageTeam(): void;
}

interface Codeable {
  code(): void;
}

interface Designable {
  designUI(): void;
}

class JuniorDeveloper implements Workable, Eatable, Sleepable, Codeable {
  work(): void { console.log("Junior dev working..."); }
  eat(): void { console.log("Junior dev eating..."); }
  sleep(): void { console.log("Junior dev sleeping..."); }
  code(): void { console.log("Junior dev coding..."); }
  // manageTeam()이나 designUI()는 구현할 필요가 없습니다.
}

class CEO implements Workable, Eatable, Sleepable, Managable {
  work(): void { console.log("CEO working..."); }
  eat(): void { console.log("CEO eating..."); }
  sleep(): void { console.log("CEO sleeping..."); }
  manageTeam(): void { console.log("CEO managing team..."); }
  // code()나 designUI()는 구현할 필요가 없습니다.
}

// 각 구현 클래스는 자신이 제공하는 능력의 인터페이스만 구현합니다.
// 이는 불필요한 구현을 강제하지 않고 코드의 유연성을 높입니다.

interface Codeable {
  code(): void;
}

function runCodingTask(worker: Codeable): void {
  worker.code();
}

const codeOnly = {
  code(): void { console.log("코딩 작업 완료"); },
};
runCodingTask(codeOnly);

// 저수준 모듈: 파일 시스템에 직접 로그를 기록
class FileLogger {
  log(message: string): void {
    console.log(`[File Log]: ${message}`);
    // 실제 파일 쓰기 로직 (생략)
  }
}

// 고수준 모듈: 특정 로거 구현체(FileLogger)에 직접 의존
class PaymentProcessor {
  private fileLogger: FileLogger; // FileLogger 구체 클래스에 직접 의존

  constructor() {
    this.fileLogger = new FileLogger(); // 직접 인스턴스 생성
  }

  processPayment(amount: number): void {
    // 결제 처리 로직...
    this.fileLogger.log(`Payment processed: ${amount}`); // FileLogger에 직접 의존
  }
}

// 만약 로그 시스템을 데이터베이스 로거로 변경하려면 PaymentProcessor 코드를 수정해야 합니다.

// 추상화: 로거 인터페이스 (고수준 모듈과 저수준 모듈 모두 이 인터페이스에 의존)
interface ILogger {
  log(message: string): void;
}

// 저수준 모듈 구현: 파일 시스템 로거 (ILogger 추상화에 의존)
class FileLogger implements ILogger {
  log(message: string): void {
    console.log(`[File Log]: ${message}`);
    // 실제 파일 쓰기 로직
  }
}

// 저수준 모듈 구현: 데이터베이스 로거 (ILogger 추상화에 의존)
class DatabaseLogger implements ILogger {
  log(message: string): void {
    console.log(`[DB Log]: ${message}`);
    // 실제 데이터베이스 로깅 로직
  }
}

// 고수준 모듈: PaymentProcessor (ILogger 추상화에 의존)
class PaymentProcessor {
  private logger: ILogger; // 구체적인 구현체가 아닌 ILogger 인터페이스에 의존

  // 의존성 주입 (생성자 주입)
  constructor(logger: ILogger) {
    this.logger = logger;
  }

  processPayment(amount: number): void {
    // 결제 처리 로직...
    this.logger.log(`Payment processed: ${amount}`); // ILogger 인터페이스를 통해 로그
  }
}

// 사용 예시
const fileLogger = new FileLogger();
const filePaymentProcessor = new PaymentProcessor(fileLogger);
filePaymentProcessor.processPayment(100); // [File Log]: Payment processed: 100

const databaseLogger = new DatabaseLogger();
const dbPaymentProcessor = new PaymentProcessor(databaseLogger);
dbPaymentProcessor.processPayment(200); // [DB Log]: Payment processed: 200

// PaymentProcessor는 FileLogger나 DatabaseLogger에 직접 의존하지 않고,
// ILogger라는 추상화에 의존합니다. 새로운 로거 구현체가 추가되어도 PaymentProcessor는 변경할 필요가 없습니다.

interface Flyable {
  fly(): void;
}

function makeFlyingAnimalFly(animal: Flyable): void {
  animal.fly();
}

const brokenFlyer = {
  fly(): void {
    throw new Error("비행 동작을 제공하지 않습니다");
  },
};

makeFlyingAnimalFly(brokenFlyer);