// 추상 클래스 — 알고리즘의 뼈대를 정의
abstract class DataProcessor<T> {
  // 🔒 Template Method — 이 순서는 바꿀 수 없다
  process(source: string): void {
    const raw = this.read(source);
    const parsed = this.parse(raw);
    this.validate(parsed);
    const transformed = this.transform(parsed);
    this.save(transformed);
 
    console.log("✅ 파이프라인 완료!");
  }
 
  // 서브클래스가 반드시 구현해야 하는 단계들
  protected abstract read(source: string): string;
  protected abstract parse(raw: string): T[];
  protected abstract validate(data: T[]): void;
  protected abstract transform(data: T[]): T[];
 
  // Hook — 기본 구현이 있지만, 필요하면 오버라이드 가능
  protected save(data: T[]): void {
    console.log(`💾 ${data.length}건 저장 완료`);
  }
}

interface CsvRecord {
  name: string;
  email: string;
  age: number;
}
 
class CsvProcessor extends DataProcessor<CsvRecord> {
  protected read(source: string): string {
    console.log(`📄 CSV 파일 읽는 중: ${source}`);
    // 실제로는 fs.readFileSync 등을 사용
    return "name,email,age\n홍길동,hong@test.com,25\n김철수,kim@test.com,17";
  }
 
  protected parse(raw: string): CsvRecord[] {
    const [header, ...rows] = raw.split("\n");
    const keys = header.split(",");
 
    return rows.map((row) => {
      const values = row.split(",");
      return {
        name: values[0],
        email: values[1],
        age: Number(values[2]),
      };
    });
  }
 
  protected validate(data: CsvRecord[]): void {
    for (const record of data) {
      if (!record.email.includes("@")) {
        throw new Error(`유효하지 않은 이메일: ${record.email}`);
      }
      if (record.age < 0 || record.age > 150) {
        throw new Error(`유효하지 않은 나이: ${record.age}`);
      }
    }
    console.log(`✅ ${data.length}건 검증 통과`);
  }
 
  protected transform(data: CsvRecord[]): CsvRecord[] {
    // 미성년자 필터링
    return data.filter((record) => record.age >= 18);
  }
}

interface JsonRecord {
  id: string;
  payload: Record<string, unknown>;
  timestamp: number;
}
 
class JsonProcessor extends DataProcessor<JsonRecord> {
  protected read(source: string): string {
    console.log(`📋 JSON API 호출 중: ${source}`);
    return JSON.stringify([
      { id: "a1", payload: { action: "click" }, timestamp: Date.now() },
      {
        id: "a2",
        payload: { action: "scroll" },
        timestamp: Date.now() - 100000,
      },
    ]);
  }
 
  protected parse(raw: string): JsonRecord[] {
    return JSON.parse(raw);
  }
 
  protected validate(data: JsonRecord[]): void {
    for (const record of data) {
      if (!record.id || !record.payload) {
        throw new Error("필수 필드가 누락되었습니다");
      }
    }
    console.log(`✅ ${data.length}건 검증 통과`);
  }
 
  protected transform(data: JsonRecord[]): JsonRecord[] {
    // 최근 1시간 이내 이벤트만 남기기
    const oneHourAgo = Date.now() - 3600000;
    return data.filter((record) => record.timestamp > oneHourAgo);
  }
 
  // Hook 오버라이드 — 저장 방식 커스터마이징
  protected save(data: JsonRecord[]): void {
    console.log(`🗄️ NoSQL DB에 ${data.length}건 벌크 저장 완료`);
  }
}

const csvProcessor = new CsvProcessor();
csvProcessor.process("users.csv");
// 📄 CSV 파일 읽는 중: users.csv
// ✅ 2건 검증 통과
// 💾 1건 저장 완료
// ✅ 파이프라인 완료!
 
const jsonProcessor = new JsonProcessor();
jsonProcessor.process("https://api.example.com/events");
// 📋 JSON API 호출 중: https://api.example.com/events
// ✅ 2건 검증 통과
// 🗄️ NoSQL DB에 1건 벌크 저장 완료
// ✅ 파이프라인 완료!

// React가 정해놓은 생명주기 흐름:
// constructor → render → componentDidMount → (update) → componentWillUnmount
// 우리는 각 단계의 "내용"만 채운다
 
class UserProfile extends React.Component<Props, State> {
  // 1단계: 초기화
  constructor(props: Props) {
    super(props);
    this.state = { user: null, loading: true };
  }
 
  // 2단계: 마운트 후 데이터 로딩
  componentDidMount() {
    fetchUser(this.props.userId).then((user) => {
      this.setState({ user, loading: false });
    });
  }
 
  // 3단계: 렌더링
  render() {
    if (this.state.loading) return <Spinner />;
    return <div>{this.state.user.name}</div>;
  }
 
  // 4단계: 정리
  componentWillUnmount() {
    // 구독 해제, 타이머 정리 등
  }
}

// 테스트 프레임워크의 흐름: setup → test → teardown
// 이것도 Template Method다
 
describe("UserService", () => {
  let db: Database;
 
  // 1단계: 준비
  beforeEach(() => {
    db = new TestDatabase();
    db.seed(testData);
  });
 
  // 2단계: 실행
  it("should create user", () => {
    const user = userService.create({ name: "테스트" });
    expect(user.id).toBeDefined();
  });
 
  // 3단계: 정리
  afterEach(() => {
    db.cleanup();
  });
});

// Template Method — 상속으로 단계를 변경
abstract class Sorter {
  sort(data: number[]): number[] {
    this.preProcess(data);
    const result = this.doSort(data);
    this.postProcess(result);
    return result;
  }
 
  protected preProcess(data: number[]): void {
    /* 기본 구현 */
  }
  protected abstract doSort(data: number[]): number[];
  protected postProcess(data: number[]): void {
    /* 기본 구현 */
  }
}
 
// Strategy — 합성으로 알고리즘 자체를 교체
interface SortStrategy {
  sort(data: number[]): number[];
}
 
class DataSorter {
  constructor(private strategy: SortStrategy) {}
 
  sort(data: number[]): number[] {
    return this.strategy.sort(data);
  }
 
  // 런타임에 전략 변경 가능!
  setStrategy(strategy: SortStrategy): void {
    this.strategy = strategy;
  }
}