Factory Pattern - 객체를 만드는 똑똑한 방법

// 사용자 객체를 만들어야 하는데...
const user1 = {
  id: 1,
  name: '홍길동',
  email: 'hong@example.com',
  role: 'admin',
  createdAt: new Date(),
  isActive: true
};

const user2 = {
  id: 2,
  name: '김철수',
  email: 'kim@example.com',
  role: 'user',
  createdAt: new Date(),
  isActive: true
};

const user3 = {
  id: 3,
  name: '이영희',
  email: 'lee@example.com',
  role: 'user',
  createdAt: new Date(),
  isActive: true
};

// ❌ 변환 로직이 코드 곳곳에 흩어져 있음
function fetchUsers() {
  return api.get('/users').then(users => {
    return users.map(user => ({
      ...user,
      fullName: `${user.firstName} ${user.lastName}`,
      isAdmin: user.role === 'admin'
    }));
  });
}

function fetchUserProfile(id) {
  return api.get(`/users/${id}`).then(user => ({
    ...user,
    fullName: `${user.firstName} ${user.lastName}`,
    isAdmin: user.role === 'admin'
  }));
}

// 같은 변환 로직이 반복됨!

// ✅ 변환 로직이 한 곳에만 있음
const UserFactory = {
  create(userData) {
    return {
      ...userData,
      fullName: `${userData.firstName} ${userData.lastName}`,
      isAdmin: userData.role === 'admin'
    };
  }
};

function fetchUsers() {
  return api.get('/users').then(users => users.map(UserFactory.create));
}

function fetchUserProfile(id) {
  return api.get(`/users/${id}`).then(UserFactory.create);
}

// ❌ 복잡한 초기화 로직이 노출됨
const warrior = {
  name: '전사',
  hp: 100,
  mp: 50,
  attack: 20,
  defense: 15,
  skills: ['강타', '방패막기'],
  inventory: [],
  equipment: {
    weapon: null,
    armor: null,
    accessory: null
  },
  stats: {
    strength: 10,
    agility: 5,
    intelligence: 3
  }
};

// 매번 이렇게 긴 객체를 만들어야 한다면?

// ✅ 사용자는 간단하게 호출만 하면 됨
function createWarrior(name) {
  return {
    name,
    hp: 100,
    mp: 50,
    attack: 20,
    defense: 15,
    skills: ['강타', '방패막기'],
    inventory: [],
    equipment: { weapon: null, armor: null, accessory: null },
    stats: { strength: 10, agility: 5, intelligence: 3 }
  };
}

const warrior = createWarrior('홍길동');

// ❌ 조건 분기가 사용하는 곳마다 반복됨
function handlePayment(type, amount) {
  let payment;
  if (type === 'credit-card') {
    payment = new CreditCardPayment(amount);
  } else if (type === 'paypal') {
    payment = new PayPalPayment(amount);
  } else if (type === 'bank-transfer') {
    payment = new BankTransferPayment(amount);
  }
  return payment.process();
}

// ✅ Factory에서 조건 분기를 처리
const PaymentFactory = {
  create(type, amount) {
    switch (type) {
      case 'credit-card':
        return new CreditCardPayment(amount);
      case 'paypal':
        return new PayPalPayment(amount);
      case 'bank-transfer':
        return new BankTransferPayment(amount);
      default:
        throw new Error(`Unknown payment type: ${type}`);
    }
  }
};

function handlePayment(type, amount) {
  const payment = PaymentFactory.create(type, amount);
  return payment.process();
}

const product1 = {
  id: 1,
  name: '노트북',
  price: 1500000,
  category: 'electronics',
  image: '/images/laptop.jpg',
  discount: 0,
  finalPrice: 1500000,
  isOnSale: false,
  displayPrice: '1,500,000원'
};

const product2 = {
  id: 2,
  name: '키보드',
  price: 150000,
  category: 'electronics',
  image: '/images/keyboard.jpg',
  discount: 0.1,
  finalPrice: 135000,
  isOnSale: true,
  displayPrice: '135,000원'
};

const product3 = {
  id: 3,
  name: '마우스',
  price: 80000,
  category: 'electronics',
  image: '/images/mouse.jpg',
  discount: 0.15,
  finalPrice: 68000,
  isOnSale: true,
  displayPrice: '68,000원'
};

function formatPrice(price) {
  return price.toLocaleString('ko-KR') + '원';
}

function calculateFinalPrice(price, discount) {
  return Math.floor(price * (1 - discount));
}

const product1 = {
  id: 1,
  name: '노트북',
  price: 1500000,
  category: 'electronics',
  image: '/images/laptop.jpg',
  discount: 0,
  finalPrice: calculateFinalPrice(1500000, 0),
  isOnSale: 0 > 0,
  displayPrice: formatPrice(calculateFinalPrice(1500000, 0))
};

// 여전히 복잡하고 실수하기 쉽습니다

function createProduct(data) {
  const { id, name, price, category, image, discount = 0 } = data;
  const finalPrice = Math.floor(price * (1 - discount));

  return {
    id,
    name,
    price,
    category,
    image,
    discount,
    finalPrice,
    isOnSale: discount > 0,
    displayPrice: finalPrice.toLocaleString('ko-KR') + '원',
    // 추가 메서드도 쉽게 넣을 수 있음
    applyAdditionalDiscount(extraDiscount) {
      const newPrice = Math.floor(this.finalPrice * (1 - extraDiscount));
      return createProduct({
        ...data,
        discount: 1 - (newPrice / price)
      });
    }
  };
}

// 사용하기
const product1 = createProduct({
  id: 1,
  name: '노트북',
  price: 1500000,
  category: 'electronics',
  image: '/images/laptop.jpg'
});

const product2 = createProduct({
  id: 2,
  name: '키보드',
  price: 150000,
  category: 'electronics',
  image: '/images/keyboard.jpg',
  discount: 0.1
});

console.log(product2.displayPrice); // "135,000원"
console.log(product2.isOnSale);     // true

// 사용자는 이렇게만 호출
const user = createUser({ name: '홍길동', email: 'hong@example.com' });

// 내부의 복잡한 로직은 모름
function createUser(data) {
  // 1. 데이터 검증
  if (!data.email || !data.email.includes('@')) {
    throw new Error('Invalid email');
  }

  // 2. 기본값 설정
  const id = generateUUID();
  const createdAt = new Date();
  const role = data.role || 'user';

  // 3. 추가 속성 계산
  const displayName = data.displayName || data.name;
  const initials = data.name.split(' ').map(n => n[0]).join('');

  // 4. 객체 반환
  return {
    id,
    name: data.name,
    email: data.email,
    role,
    displayName,
    initials,
    createdAt,
    isActive: true
  };
}

function createTask(title, priority = 'medium') {
  return {
    id: Date.now(),
    title,
    priority,
    status: 'pending',
    createdAt: new Date(),
    completedAt: null,
    // 모든 task는 이 메서드들을 가짐
    complete() {
      this.status = 'completed';
      this.completedAt = new Date();
    },
    cancel() {
      this.status = 'cancelled';
    }
  };
}

// 모든 task가 일관된 인터페이스를 가짐
const task1 = createTask('코드 리뷰');
const task2 = createTask('버그 수정', 'high');

task1.complete(); // 모두 같은 방식으로 작동
task2.complete();

function createAnimal(type, name) {
  const base = {
    name,
    type,
    eat() {
      console.log(`${this.name}이 먹이를 먹습니다.`);
    }
  };

  // 타입에 따라 다른 속성과 메서드 추가
  if (type === 'dog') {
    return {
      ...base,
      breed: 'Unknown',
      bark() {
        console.log(`${this.name}: 멍멍!`);
      }
    };
  } else if (type === 'cat') {
    return {
      ...base,
      furColor: 'Unknown',
      meow() {
        console.log(`${this.name}: 야옹~`);
      }
    };
  } else if (type === 'bird') {
    return {
      ...base,
      canFly: true,
      chirp() {
        console.log(`${this.name}: 짹짹!`);
      }
    };
  }

  return base;
}

const dog = createAnimal('dog', '뭉치');
dog.bark(); // "뭉치: 멍멍!"

const cat = createAnimal('cat', '나비');
cat.meow(); // "나비: 야옹~"

function createProduct(data) {
  // === 1단계: 입력 검증 ===
  if (!data.name || !data.price) {
    throw new Error('Name and price are required');
  }

  if (data.price < 0) {
    throw new Error('Price must be positive');
  }

  // === 2단계: 기본값 설정 ===
  const id = data.id || generateId();
  const discount = data.discount || 0;
  const category = data.category || 'general';

  // === 3단계: 추가 속성 계산 ===
  const finalPrice = Math.floor(data.price * (1 - discount));
  const isOnSale = discount > 0;
  const displayPrice = formatCurrency(finalPrice);
  const savings = data.price - finalPrice;

  // === 4단계: 객체 생성 ===
  const product = {
    id,
    name: data.name,
    price: data.price,
    category,
    discount,
    finalPrice,
    isOnSale,
    displayPrice,
    savings,
    createdAt: new Date()
  };

  // === 5단계: 메서드 추가 ===
  product.applyDiscount = function(extraDiscount) {
    return createProduct({
      ...data,
      discount: Math.min(discount + extraDiscount, 0.9) // 최대 90% 할인
    });
  };

  product.toString = function() {
    return `${this.name} - ${this.displayPrice}`;
  };

  // === 6단계: 반환 ===
  return product;
}

// 헬퍼 함수들
function generateId() {
  return `prod_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}

function formatCurrency(price) {
  return price.toLocaleString('ko-KR') + '원';
}

// 디버깅을 위한 추적 기능 추가
function createProductWithLogging(data) {
  console.log('1️⃣ Factory 호출됨:', data);

  if (!data.name || !data.price) {
    console.error('❌ 검증 실패: 필수 필드 누락');
    throw new Error('Name and price are required');
  }
  console.log('✅ 검증 통과');

  const id = data.id || generateId();
  console.log('2️⃣ ID 생성:', id);

  const finalPrice = Math.floor(data.price * (1 - (data.discount || 0)));
  console.log('3️⃣ 가격 계산:', {
    original: data.price,
    discount: data.discount || 0,
    final: finalPrice
  });

  const product = {
    id,
    name: data.name,
    price: data.price,
    finalPrice,
    displayPrice: formatCurrency(finalPrice)
  };

  console.log('4️⃣ 객체 생성 완료:', product);
  return product;
}

// 실행 예시
const product = createProductWithLogging({
  name: '노트북',
  price: 1000000,
  discount: 0.1
});

// 콘솔 출력:
// 1️⃣ Factory 호출됨: { name: '노트북', price: 1000000, discount: 0.1 }
// ✅ 검증 통과
// 2️⃣ ID 생성: prod_1234567890_abc123xyz
// 3️⃣ 가격 계산: { original: 1000000, discount: 0.1, final: 900000 }
// 4️⃣ 객체 생성 완료: { id: '...', name: '노트북', ... }

// 간단한 함수 형태
function createUser(name, email) {
  return {
    id: generateId(),
    name,
    email,
    createdAt: new Date(),
    isActive: true,
    greet() {
      return `안녕하세요, ${this.name}입니다.`;
    }
  };
}

const user = createUser('홍길동', 'hong@example.com');

const UserFactory = {
  create(name, email, role = 'user') {
    const base = {
      id: generateId(),
      name,
      email,
      role,
      createdAt: new Date(),
      isActive: true
    };

    // role에 따라 다른 권한 추가
    if (role === 'admin') {
      base.permissions = ['read', 'write', 'delete', 'manage'];
      base.canManageUsers = true;
    } else if (role === 'moderator') {
      base.permissions = ['read', 'write', 'moderate'];
      base.canModerate = true;
    } else {
      base.permissions = ['read'];
    }

    return base;
  },

  createAdmin(name, email) {
    return this.create(name, email, 'admin');
  },

  createModerator(name, email) {
    return this.create(name, email, 'moderator');
  },

  createGuest() {
    return {
      id: 'guest',
      name: 'Guest',
      email: null,
      role: 'guest',
      permissions: ['read'],
      isActive: true,
      createdAt: new Date()
    };
  }
};

// 사용
const admin = UserFactory.createAdmin('관리자', 'admin@example.com');
const user = UserFactory.create('홍길동', 'hong@example.com');
const guest = UserFactory.createGuest();

console.log(admin.canManageUsers); // true
console.log(user.permissions);     // ['read']

class VehicleFactory {
  constructor() {
    this.vehicleCount = 0;
  }

  createVehicle(type, options) {
    this.vehicleCount++;

    const baseVehicle = {
      id: this.vehicleCount,
      type,
      color: options.color || 'white',
      year: options.year || new Date().getFullYear(),
      createdAt: new Date()
    };

    switch (type) {
      case 'car':
        return {
          ...baseVehicle,
          doors: options.doors || 4,
          engine: options.engine || 'gasoline',
          drive() {
            console.log(`${this.color} 자동차가 달립니다.`);
          }
        };

      case 'motorcycle':
        return {
          ...baseVehicle,
          engineSize: options.engineSize || 125,
          hasSideCar: options.hasSideCar || false,
          ride() {
            console.log(`${this.color} 오토바이를 탑니다.`);
          }
        };

      case 'truck':
        return {
          ...baseVehicle,
          capacity: options.capacity || 1000,
          axles: options.axles || 2,
          loadCargo(weight) {
            if (weight <= this.capacity) {
              console.log(`${weight}kg 화물을 실었습니다.`);
            } else {
              console.log(`용량 초과! 최대 ${this.capacity}kg만 실을 수 있습니다.`);
            }
          }
        };

      default:
        throw new Error(`Unknown vehicle type: ${type}`);
    }
  }

  getStats() {
    return {
      totalVehiclesCreated: this.vehicleCount
    };
  }
}

// 사용
const factory = new VehicleFactory();

const car = factory.createVehicle('car', { color: 'red', doors: 2 });
const motorcycle = factory.createVehicle('motorcycle', { engineSize: 250 });
const truck = factory.createVehicle('truck', { capacity: 5000 });

car.drive();              // "red 자동차가 달립니다."
motorcycle.ride();        // "white 오토바이를 탑니다."
truck.loadCargo(3000);   // "3000kg 화물을 실었습니다."

console.log(factory.getStats()); // { totalVehiclesCreated: 3 }

// UI 컴포넌트를 테마별로 만드는 예제
function createUIFactory(theme) {
  if (theme === 'dark') {
    return {
      createButton(text) {
        return {
          text,
          backgroundColor: '#333',
          textColor: '#fff',
          border: '1px solid #555',
          render() {
            return `<button style="background: ${this.backgroundColor}; color: ${this.textColor}; border: ${this.border}">${this.text}</button>`;
          }
        };
      },

      createInput(placeholder) {
        return {
          placeholder,
          backgroundColor: '#222',
          textColor: '#fff',
          border: '1px solid #444',
          render() {
            return `<input placeholder="${this.placeholder}" style="background: ${this.backgroundColor}; color: ${this.textColor}; border: ${this.border}">`;
          }
        };
      }
    };
  } else if (theme === 'light') {
    return {
      createButton(text) {
        return {
          text,
          backgroundColor: '#fff',
          textColor: '#000',
          border: '1px solid #ddd',
          render() {
            return `<button style="background: ${this.backgroundColor}; color: ${this.textColor}; border: ${this.border}">${this.text}</button>`;
          }
        };
      },

      createInput(placeholder) {
        return {
          placeholder,
          backgroundColor: '#fff',
          textColor: '#000',
          border: '1px solid #ccc',
          render() {
            return `<input placeholder="${this.placeholder}" style="background: ${this.backgroundColor}; color: ${this.textColor}; border: ${this.border}">`;
          }
        };
      }
    };
  }
}

// 사용
const darkFactory = createUIFactory('dark');
const lightFactory = createUIFactory('light');

const darkButton = darkFactory.createButton('클릭');
const darkInput = darkFactory.createInput('검색...');

const lightButton = lightFactory.createButton('클릭');
const lightInput = lightFactory.createInput('검색...');

console.log(darkButton.render());  // 다크 테마 버튼 HTML
console.log(lightButton.render()); // 라이트 테마 버튼 HTML

function createQueryBuilder() {
  const query = {
    table: null,
    columns: ['*'],
    whereConditions: [],
    orderBy: null,
    limit: null
  };

  return {
    from(table) {
      query.table = table;
      return this;
    },

    select(...columns) {
      query.columns = columns;
      return this;
    },

    where(condition) {
      query.whereConditions.push(condition);
      return this;
    },

    orderBy(column, direction = 'ASC') {
      query.orderBy = { column, direction };
      return this;
    },

    limit(count) {
      query.limit = count;
      return this;
    },

    build() {
      if (!query.table) {
        throw new Error('Table name is required');
      }

      let sql = `SELECT ${query.columns.join(', ')} FROM ${query.table}`;

      if (query.whereConditions.length > 0) {
        sql += ` WHERE ${query.whereConditions.join(' AND ')}`;
      }

      if (query.orderBy) {
        sql += ` ORDER BY ${query.orderBy.column} ${query.orderBy.direction}`;
      }

      if (query.limit) {
        sql += ` LIMIT ${query.limit}`;
      }

      return sql + ';';
    }
  };
}

// 사용
const query = createQueryBuilder()
  .from('users')
  .select('id', 'name', 'email')
  .where('age > 18')
  .where('isActive = true')
  .orderBy('createdAt', 'DESC')
  .limit(10)
  .build();

console.log(query);
// "SELECT id, name, email FROM users WHERE age > 18 AND isActive = true ORDER BY createdAt DESC LIMIT 10;"

const RequestFactory = {
  create(config) {
    const {
      url,
      method = 'GET',
      headers = {},
      body = null,
      timeout = 5000,
      retry = 0
    } = config;

    // 기본 헤더 설정
    const defaultHeaders = {
      'Content-Type': 'application/json',
      'Accept': 'application/json'
    };

    const request = {
      url,
      method: method.toUpperCase(),
      headers: { ...defaultHeaders, ...headers },
      body: body ? JSON.stringify(body) : null,
      timeout,
      retry,
      timestamp: Date.now(),

      async execute() {
        let attempts = 0;

        while (attempts <= this.retry) {
          try {
            const controller = new AbortController();
            const timeoutId = setTimeout(() => controller.abort(), this.timeout);

            const response = await fetch(this.url, {
              method: this.method,
              headers: this.headers,
              body: this.body,
              signal: controller.signal
            });

            clearTimeout(timeoutId);

            if (!response.ok) {
              throw new Error(`HTTP ${response.status}: ${response.statusText}`);
            }

            return await response.json();
          } catch (error) {
            attempts++;

            if (attempts > this.retry) {
              throw new Error(`Request failed after ${attempts} attempts: ${error.message}`);
            }

            // 재시도 전 대기 (exponential backoff)
            await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempts)));
          }
        }
      },

      clone() {
        return RequestFactory.create({
          url: this.url,
          method: this.method,
          headers: this.headers,
          body: this.body ? JSON.parse(this.body) : null,
          timeout: this.timeout,
          retry: this.retry
        });
      },

      withHeaders(newHeaders) {
        const cloned = this.clone();
        cloned.headers = { ...cloned.headers, ...newHeaders };
        return cloned;
      }
    };

    return request;
  },

  get(url, config = {}) {
    return this.create({ ...config, url, method: 'GET' });
  },

  post(url, body, config = {}) {
    return this.create({ ...config, url, method: 'POST', body });
  },

  put(url, body, config = {}) {
    return this.create({ ...config, url, method: 'PUT', body });
  },

  delete(url, config = {}) {
    return this.create({ ...config, url, method: 'DELETE' });
  }
};

// 사용 예시
async function fetchUserProfile(userId) {
  const request = RequestFactory.get(`/api/users/${userId}`, {
    timeout: 3000,
    retry: 2
  });

  // 인증 토큰 추가
  const authRequest = request.withHeaders({
    'Authorization': `Bearer ${getToken()}`
  });

  return authRequest.execute();
}

async function updateUserProfile(userId, data) {
  const request = RequestFactory.put(`/api/users/${userId}`, data, {
    retry: 1
  });

  return request.execute();
}

const ValidationFactory = {
  required(message = '필수 입력 항목입니다.') {
    return {
      type: 'required',
      message,
      validate(value) {
        if (value === null || value === undefined || value === '') {
          return { valid: false, message: this.message };
        }
        return { valid: true };
      }
    };
  },

  minLength(length, message) {
    return {
      type: 'minLength',
      length,
      message: message || `최소 ${length}자 이상 입력해주세요.`,
      validate(value) {
        if (value.length < this.length) {
          return { valid: false, message: this.message };
        }
        return { valid: true };
      }
    };
  },

  maxLength(length, message) {
    return {
      type: 'maxLength',
      length,
      message: message || `최대 ${length}자까지 입력 가능합니다.`,
      validate(value) {
        if (value.length > this.length) {
          return { valid: false, message: this.message };
        }
        return { valid: true };
      }
    };
  },

  pattern(regex, message = '형식이 올바르지 않습니다.') {
    return {
      type: 'pattern',
      regex,
      message,
      validate(value) {
        if (!this.regex.test(value)) {
          return { valid: false, message: this.message };
        }
        return { valid: true };
      }
    };
  },

  email(message = '올바른 이메일 주소를 입력해주세요.') {
    return this.pattern(
      /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
      message
    );
  },

  phone(message = '올바른 전화번호를 입력해주세요.') {
    return this.pattern(
      /^01[0-9]-?[0-9]{4}-?[0-9]{4}$/,
      message
    );
  },

  custom(validatorFn, message = '유효하지 않은 값입니다.') {
    return {
      type: 'custom',
      message,
      validate(value) {
        const result = validatorFn(value);
        if (result === true) {
          return { valid: true };
        }
        return { valid: false, message: this.message };
      }
    };
  }
};

// 폼 필드 팩토리
function createFormField(name, validators = []) {
  return {
    name,
    value: '',
    validators,
    errors: [],
    touched: false,

    setValue(newValue) {
      this.value = newValue;
      this.validate();
    },

    setTouched() {
      this.touched = true;
      this.validate();
    },

    validate() {
      this.errors = [];

      for (const validator of this.validators) {
        const result = validator.validate(this.value);
        if (!result.valid) {
          this.errors.push(result.message);
        }
      }

      return this.errors.length === 0;
    },

    isValid() {
      return this.errors.length === 0;
    },

    getFirstError() {
      return this.errors[0] || null;
    }
  };
}

// 사용 예시
const emailField = createFormField('email', [
  ValidationFactory.required(),
  ValidationFactory.email()
]);

const passwordField = createFormField('password', [
  ValidationFactory.required(),
  ValidationFactory.minLength(8),
  ValidationFactory.custom(
    (value) => /[A-Z]/.test(value) && /[0-9]/.test(value),
    '비밀번호는 대문자와 숫자를 포함해야 합니다.'
  )
]);

const usernameField = createFormField('username', [
  ValidationFactory.required(),
  ValidationFactory.minLength(3),
  ValidationFactory.maxLength(20)
]);

// 사용
emailField.setValue('invalid-email');
console.log(emailField.errors); // ["올바른 이메일 주소를 입력해주세요."]

emailField.setValue('user@example.com');
console.log(emailField.isValid()); // true

passwordField.setValue('weak');
console.log(passwordField.errors);
// ["최소 8자 이상 입력해주세요.", "비밀번호는 대문자와 숫자를 포함해야 합니다."]

const LoggerFactory = {
  create(config = {}) {
    const {
      name = 'App',
      level = 'info',
      format = 'text',
      destination = 'console',
      timestamp = true
    } = config;

    const levels = {
      debug: 0,
      info: 1,
      warn: 2,
      error: 3
    };

    const colors = {
      debug: '\x1b[36m',  // Cyan
      info: '\x1b[32m',   // Green
      warn: '\x1b[33m',   // Yellow
      error: '\x1b[31m',  // Red
      reset: '\x1b[0m'
    };

    function shouldLog(logLevel) {
      return levels[logLevel] >= levels[level];
    }

    function formatMessage(logLevel, message, data) {
      const time = timestamp ? new Date().toISOString() : '';

      if (format === 'json') {
        return JSON.stringify({
          timestamp: time,
          level: logLevel,
          logger: name,
          message,
          data
        });
      } else {
        const color = colors[logLevel];
        const reset = colors.reset;
        const timeStr = time ? `[${time}] ` : '';
        const dataStr = data ? ` ${JSON.stringify(data)}` : '';

        return `${color}${timeStr}[${logLevel.toUpperCase()}] [${name}]${reset} ${message}${dataStr}`;
      }
    }

    function output(message) {
      if (destination === 'console') {
        console.log(message);
      } else if (destination === 'file') {
        // 파일에 쓰기 (Node.js 환경)
        // fs.appendFileSync('app.log', message + '\n');
      }
    }

    return {
      name,
      level,

      debug(message, data) {
        if (shouldLog('debug')) {
          output(formatMessage('debug', message, data));
        }
      },

      info(message, data) {
        if (shouldLog('info')) {
          output(formatMessage('info', message, data));
        }
      },

      warn(message, data) {
        if (shouldLog('warn')) {
          output(formatMessage('warn', message, data));
        }
      },

      error(message, data) {
        if (shouldLog('error')) {
          output(formatMessage('error', message, data));
        }
      },

      child(childName) {
        return LoggerFactory.create({
          ...config,
          name: `${name}:${childName}`
        });
      }
    };
  }
};

// 사용 예시
const appLogger = LoggerFactory.create({
  name: 'App',
  level: 'debug',
  format: 'text'
});

const dbLogger = appLogger.child('Database');
const apiLogger = appLogger.child('API');

appLogger.info('애플리케이션 시작');
dbLogger.debug('데이터베이스 연결 시도', { host: 'localhost', port: 5432 });
apiLogger.warn('API 응답 지연', { endpoint: '/users', duration: 3000 });
apiLogger.error('치명적 오류 발생', { error: 'Connection refused' });

// 프로덕션용 JSON 로거
const prodLogger = LoggerFactory.create({
  name: 'Production',
  level: 'warn',
  format: 'json'
});

prodLogger.error('서버 오류', { statusCode: 500, message: 'Internal Server Error' });

function createStateMachine(config) {
  const {
    initialState,
    states,
    transitions
  } = config;

  let currentState = initialState;
  const listeners = [];

  return {
    getCurrentState() {
      return currentState;
    },

    can(transitionName) {
      return transitions[transitionName] &&
             transitions[transitionName].from.includes(currentState);
    },

    transition(transitionName) {
      if (!this.can(transitionName)) {
        throw new Error(
          `Cannot transition '${transitionName}' from state '${currentState}'`
        );
      }

      const transition = transitions[transitionName];
      const previousState = currentState;
      currentState = transition.to;

      // 상태 진입/퇴장 훅 실행
      if (states[previousState]?.onExit) {
        states[previousState].onExit();
      }

      if (states[currentState]?.onEnter) {
        states[currentState].onEnter();
      }

      // 리스너들에게 알림
      listeners.forEach(listener => {
        listener({ from: previousState, to: currentState, transition: transitionName });
      });

      return this;
    },

    onTransition(callback) {
      listeners.push(callback);
      return () => {
        const index = listeners.indexOf(callback);
        if (index > -1) listeners.splice(index, 1);
      };
    },

    is(state) {
      return currentState === state;
    }
  };
}

// 주문 상태 기계 예시
const orderStateMachine = createStateMachine({
  initialState: 'pending',

  states: {
    pending: {
      onEnter() {
        console.log('주문이 접수되었습니다.');
      }
    },
    processing: {
      onEnter() {
        console.log('주문을 처리 중입니다.');
      }
    },
    shipped: {
      onEnter() {
        console.log('주문이 배송되었습니다.');
      }
    },
    delivered: {
      onEnter() {
        console.log('주문이 배송 완료되었습니다.');
      }
    },
    cancelled: {
      onEnter() {
        console.log('주문이 취소되었습니다.');
      }
    }
  },

  transitions: {
    confirm: {
      from: ['pending'],
      to: 'processing'
    },
    ship: {
      from: ['processing'],
      to: 'shipped'
    },
    deliver: {
      from: ['shipped'],
      to: 'delivered'
    },
    cancel: {
      from: ['pending', 'processing'],
      to: 'cancelled'
    }
  }
});

// 사용
orderStateMachine.onTransition((event) => {
  console.log(`상태 전환: ${event.from} → ${event.to}`);
});

console.log(orderStateMachine.getCurrentState()); // 'pending'
console.log(orderStateMachine.can('confirm'));    // true
console.log(orderStateMachine.can('deliver'));    // false

orderStateMachine.transition('confirm');
// "주문을 처리 중입니다."
// "상태 전환: pending → processing"

orderStateMachine.transition('ship');
orderStateMachine.transition('deliver');

// orderStateMachine.transition('cancel'); // Error: 배송 완료 후에는 취소 불가

const NotificationFactory = {
  create(type, message, options = {}) {
    const baseNotification = {
      id: generateId(),
      type,
      message,
      timestamp: new Date(),
      read: false,

      markAsRead() {
        this.read = true;
      },

      getAge() {
        const now = Date.now();
        const diff = now - this.timestamp.getTime();
        const minutes = Math.floor(diff / 60000);
        const hours = Math.floor(minutes / 60);
        const days = Math.floor(hours / 24);

        if (days > 0) return `${days}일 전`;
        if (hours > 0) return `${hours}시간 전`;
        if (minutes > 0) return `${minutes}분 전`;
        return '방금 전';
      },

      toHTML() {
        const icon = this.getIcon();
        const color = this.getColor();

        return `
          <div class="notification ${this.type}" style="border-left: 4px solid ${color}">
            <div class="notification-icon">${icon}</div>
            <div class="notification-content">
              <p class="notification-message">${this.message}</p>
              <span class="notification-time">${this.getAge()}</span>
            </div>
          </div>
        `;
      }
    };

    // 타입별 특화 속성 추가
    if (type === 'success') {
      return {
        ...baseNotification,
        duration: options.duration || 3000,
        getIcon() { return '✓'; },
        getColor() { return '#4CAF50'; }
      };
    }

    if (type === 'error') {
      return {
        ...baseNotification,
        duration: options.duration || 5000,
        error: options.error,
        retry: options.retry || null,
        getIcon() { return '✗'; },
        getColor() { return '#F44336'; },
        hasRetry() {
          return typeof this.retry === 'function';
        }
      };
    }

    if (type === 'warning') {
      return {
        ...baseNotification,
        duration: options.duration || 4000,
        action: options.action || null,
        getIcon() { return '⚠'; },
        getColor() { return '#FF9800'; }
      };
    }

    if (type === 'info') {
      return {
        ...baseNotification,
        duration: options.duration || 3000,
        link: options.link || null,
        getIcon() { return 'ℹ'; },
        getColor() { return '#2196F3'; }
      };
    }

    return baseNotification;
  },

  success(message, options) {
    return this.create('success', message, options);
  },

  error(message, error, options = {}) {
    return this.create('error', message, { ...options, error });
  },

  warning(message, options) {
    return this.create('warning', message, options);
  },

  info(message, options) {
    return this.create('info', message, options);
  }
};

// 알림 관리자
class NotificationManager {
  constructor() {
    this.notifications = [];
    this.maxNotifications = 5;
  }

  add(notification) {
    this.notifications.unshift(notification);

    // 최대 개수 제한
    if (this.notifications.length > this.maxNotifications) {
      this.notifications.pop();
    }

    // 자동 제거 (duration이 있는 경우)
    if (notification.duration) {
      setTimeout(() => {
        this.remove(notification.id);
      }, notification.duration);
    }

    return notification;
  }

  remove(id) {
    const index = this.notifications.findIndex(n => n.id === id);
    if (index !== -1) {
      this.notifications.splice(index, 1);
    }
  }

  clear() {
    this.notifications = [];
  }

  getAll() {
    return this.notifications;
  }

  getUnread() {
    return this.notifications.filter(n => !n.read);
  }
}

// 사용 예시
const manager = new NotificationManager();

// 성공 알림
manager.add(NotificationFactory.success('파일이 성공적으로 업로드되었습니다.'));

// 에러 알림 (재시도 가능)
manager.add(NotificationFactory.error(
  '서버 연결에 실패했습니다.',
  new Error('Connection timeout'),
  {
    retry: () => {
      console.log('재시도 중...');
      // 재시도 로직
    }
  }
));

// 경고 알림 (액션 포함)
manager.add(NotificationFactory.warning(
  '디스크 공간이 부족합니다.',
  {
    action: () => {
      console.log('설정으로 이동');
      // 설정 페이지로 이동
    }
  }
));

// 정보 알림 (링크 포함)
manager.add(NotificationFactory.info(
  '새로운 기능이 추가되었습니다.',
  {
    link: '/whats-new'
  }
));

// 알림 표시
manager.getAll().forEach(notification => {
  console.log(notification.toHTML());
});

const TransformerFactory = {
  // 필터 변환기
  filter(predicate) {
    return {
      type: 'filter',
      transform(data) {
        return Array.isArray(data) ? data.filter(predicate) : data;
      }
    };
  },

  // 매핑 변환기
  map(mapper) {
    return {
      type: 'map',
      transform(data) {
        return Array.isArray(data) ? data.map(mapper) : mapper(data);
      }
    };
  },

  // 정렬 변환기
  sort(compareFn) {
    return {
      type: 'sort',
      transform(data) {
        return Array.isArray(data) ? [...data].sort(compareFn) : data;
      }
    };
  },

  // 그룹화 변환기
  groupBy(keyFn) {
    return {
      type: 'groupBy',
      transform(data) {
        if (!Array.isArray(data)) return data;

        return data.reduce((groups, item) => {
          const key = keyFn(item);
          if (!groups[key]) {
            groups[key] = [];
          }
          groups[key].push(item);
          return groups;
        }, {});
      }
    };
  },

  // 집계 변환기
  aggregate(reduceFn, initialValue) {
    return {
      type: 'aggregate',
      transform(data) {
        return Array.isArray(data) ? data.reduce(reduceFn, initialValue) : data;
      }
    };
  },

  // 페이지네이션 변환기
  paginate(page, pageSize) {
    return {
      type: 'paginate',
      transform(data) {
        if (!Array.isArray(data)) return data;

        const start = (page - 1) * pageSize;
        const end = start + pageSize;

        return {
          data: data.slice(start, end),
          page,
          pageSize,
          total: data.length,
          totalPages: Math.ceil(data.length / pageSize)
        };
      }
    };
  }
};

// 파이프라인 생성
function createPipeline(...transformers) {
  return {
    transformers,

    process(data) {
      return transformers.reduce((result, transformer) => {
        return transformer.transform(result);
      }, data);
    },

    add(transformer) {
      return createPipeline(...this.transformers, transformer);
    }
  };
}

// 사용 예시
const users = [
  { id: 1, name: '홍길동', age: 25, role: 'admin' },
  { id: 2, name: '김철수', age: 30, role: 'user' },
  { id: 3, name: '이영희', age: 28, role: 'user' },
  { id: 4, name: '박민수', age: 35, role: 'admin' },
  { id: 5, name: '정수진', age: 27, role: 'user' }
];

// 파이프라인 구성
const pipeline = createPipeline(
  TransformerFactory.filter(user => user.age >= 27),
  TransformerFactory.map(user => ({
    ...user,
    displayName: `${user.name} (${user.age}세)`
  })),
  TransformerFactory.sort((a, b) => b.age - a.age)
);

const result = pipeline.process(users);
console.log(result);
// [
//   { id: 4, name: '박민수', age: 35, role: 'admin', displayName: '박민수 (35세)' },
//   { id: 2, name: '김철수', age: 30, role: 'user', displayName: '김철수 (30세)' },
//   { id: 3, name: '이영희', age: 28, role: 'user', displayName: '이영희 (28세)' },
//   { id: 5, name: '정수진', age: 27, role: 'user', displayName: '정수진 (27세)' }
// ]

// 동적으로 변환기 추가
const paginatedPipeline = pipeline.add(
  TransformerFactory.paginate(1, 2)
);

const paginatedResult = paginatedPipeline.process(users);
console.log(paginatedResult);
// {
//   data: [...2개 항목...],
//   page: 1,
//   pageSize: 2,
//   total: 4,
//   totalPages: 2
// }

// === Constructor Function ===
function User(name, email) {
  this.name = name;
  this.email = email;
  this.createdAt = new Date();
}

User.prototype.greet = function() {
  return `안녕하세요, ${this.name}입니다.`;
};

const user1 = new User('홍길동', 'hong@example.com');

// === Factory Function ===
function createUser(name, email) {
  return {
    name,
    email,
    createdAt: new Date(),
    greet() {
      return `안녕하세요, ${this.name}입니다.`;
    }
  };
}

const user2 = createUser('홍길동', 'hong@example.com');

// === Class ===
class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
    this.createdAt = new Date();
  }

  greet() {
    return `안녕하세요, ${this.name}입니다.`;
  }

  static create(data) {
    return new User(data.name, data.email);
  }
}

const user1 = new User('홍길동', 'hong@example.com');
const user2 = User.create({ name: '김철수', email: 'kim@example.com' });

// === Factory Pattern ===
const UserFactory = {
  create(data) {
    return {
      name: data.name,
      email: data.email,
      createdAt: new Date(),
      greet() {
        return `안녕하세요, ${this.name}입니다.`;
      }
    };
  },

  createAdmin(data) {
    return {
      ...this.create(data),
      role: 'admin',
      permissions: ['read', 'write', 'delete']
    };
  }
};

const user3 = UserFactory.create({ name: '이영희', email: 'lee@example.com' });
const admin = UserFactory.createAdmin({ name: '관리자', email: 'admin@example.com' });

// === Object Literal ===
const config = {
  apiUrl: 'https://api.example.com',
  timeout: 5000,
  retries: 3
};

// === Factory Pattern ===
function createConfig(environment) {
  const base = {
    timeout: 5000,
    retries: 3
  };

  if (environment === 'development') {
    return {
      ...base,
      apiUrl: 'http://localhost:3000',
      debug: true
    };
  } else if (environment === 'production') {
    return {
      ...base,
      apiUrl: 'https://api.example.com',
      debug: false,
      logging: true
    };
  }

  return base;
}

const devConfig = createConfig('development');
const prodConfig = createConfig('production');

// ❌ 나쁜 예: 너무 복잡한 Factory
const SuperComplexFactory = {
  create(type, subtype, options, context, metadata, callbacks) {
    // 100줄 이상의 복잡한 로직...

    if (type === 'A') {
      if (subtype === 'A1') {
        if (options.mode === 'advanced') {
          // 더 복잡한 조건들...
        }
      }
    }
    // 이해하기 어렵고 유지보수하기 힘듦
  }
};

// ✅ 좋은 예: 적절한 수준의 추상화
const UserFactory = {
  create(data) {
    return this.createBase(data);
  },

  createAdmin(data) {
    return {
      ...this.createBase(data),
      role: 'admin',
      permissions: this.getAdminPermissions()
    };
  },

  createBase(data) {
    return {
      id: generateId(),
      name: data.name,
      email: data.email,
      createdAt: new Date()
    };
  },

  getAdminPermissions() {
    return ['read', 'write', 'delete', 'manage'];
  }
};