// 問題: 引数が増えるとどれが何か分からない
//                  name    email      age  role   notify  theme   lang  tz
new User("Taro", "t@x.com", 30, "admin", true, "dark", "ja", "Asia/Tokyo");
//                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//                                  6番目以降が何を表すか、読み手には分からない
 
// さらに問題: オプション引数がある場合
new User("Taro", "t@x.com", 30, undefined, true, undefined, "ja");
//                                ^^^^^^^^         ^^^^^^^^
//                                何を省略したのか不明

// Builder なら自己文書化される
const user = User.builder()
  .setName("Taro")
  .setEmail("t@x.com")
  .setAge(30)
  .setRole("admin")
  .enableNotifications(true)
  .setTheme("dark")
  .setLanguage("ja")
  .setTimezone("Asia/Tokyo")
  .build();
 
// 利点:
// 1. 各値の意味が明確（自己文書化）
// 2. 順序に依存しない
// 3. オプション値は省略するだけでデフォルト値が適用
// 4. build() でバリデーションを集約できる

class HttpRequest {
  readonly method: string;
  readonly url: string;
  readonly headers: Readonly<Record<string, string>>;
  readonly body?: string;
  readonly timeout: number;
  readonly retries: number;
 
  private constructor(builder: HttpRequestBuilder) {
    this.method  = builder.method;
    this.url     = builder.url;
    this.headers = Object.freeze({ ...builder.headers });
    this.body    = builder.body;
    this.timeout = builder.timeout;
    this.retries = builder.retries;
  }
 
  static builder(method: string, url: string): HttpRequestBuilder {
    return new HttpRequestBuilder(method, url);
  }
 
  toString(): string {
    return `${this.method} ${this.url} (timeout=${this.timeout}ms, retries=${this.retries})`;
  }
}
 
class HttpRequestBuilder {
  method: string;
  url: string;
  headers: Record<string, string> = {};
  body?: string;
  timeout: number = 30_000;
  retries: number = 3;
 
  constructor(method: string, url: string) {
    this.method = method;
    this.url = url;
  }
 
  setHeader(key: string, value: string): this {
    this.headers[key] = value;
    return this;  // this を返すことでメソッドチェーンを実現
  }
 
  setBody(body: string): this {
    this.body = body;
    return this;
  }
 
  setTimeout(ms: number): this {
    if (ms <= 0) throw new Error("Timeout must be positive");
    this.timeout = ms;
    return this;
  }
 
  setRetries(count: number): this {
    if (count < 0) throw new Error("Retries must be non-negative");
    this.retries = count;
    return this;
  }
 
  build(): HttpRequest {
    // バリデーション
    if (!this.method) throw new Error("Method is required");
    if (!this.url) throw new Error("URL is required");
 
    return new (HttpRequest as any)(this);
  }
}
 
// 使用
const req = HttpRequest.builder("POST", "/api/users")
  .setHeader("Content-Type", "application/json")
  .setHeader("Authorization", "Bearer token123")
  .setBody(JSON.stringify({ name: "Taro", age: 30 }))
  .setTimeout(5000)
  .setRetries(2)
  .build();
 
console.log(req.toString());
// POST /api/users (timeout=5000ms, retries=2)
console.log(req.headers);
// { "Content-Type": "application/json", "Authorization": "Bearer token123" }

interface QueryBuilder {
  select(columns: string): this;
  from(table: string): this;
  where(condition: string): this;
  orderBy(column: string, direction: "ASC" | "DESC"): this;
  limit(count: number): this;
  offset(count: number): this;
  build(): string;
}
 
class SQLQueryBuilder implements QueryBuilder {
  private parts = {
    select: "",
    from: "",
    where: [] as string[],
    orderBy: "",
    limit: 0,
    offset: 0,
  };
 
  select(columns: string): this {
    this.parts.select = columns;
    return this;
  }
  from(table: string): this {
    this.parts.from = table;
    return this;
  }
  where(condition: string): this {
    this.parts.where.push(condition);
    return this;
  }
  orderBy(column: string, direction: "ASC" | "DESC"): this {
    this.parts.orderBy = `${column} ${direction}`;
    return this;
  }
  limit(count: number): this {
    this.parts.limit = count;
    return this;
  }
  offset(count: number): this {
    this.parts.offset = count;
    return this;
  }
 
  build(): string {
    let sql = `SELECT ${this.parts.select} FROM ${this.parts.from}`;
    if (this.parts.where.length > 0) {
      sql += ` WHERE ${this.parts.where.join(" AND ")}`;
    }
    if (this.parts.orderBy) sql += ` ORDER BY ${this.parts.orderBy}`;
    if (this.parts.limit) sql += ` LIMIT ${this.parts.limit}`;
    if (this.parts.offset) sql += ` OFFSET ${this.parts.offset}`;
    return sql;
  }
}
 
// Director: 構築手順を再利用可能にカプセル化
class QueryDirector {
  buildPaginatedQuery(builder: QueryBuilder, table: string, page: number, size: number): string {
    return builder
      .select("*")
      .from(table)
      .where("active = true")
      .orderBy("created_at", "DESC")
      .limit(size)
      .offset((page - 1) * size)
      .build();
  }
 
  buildCountQuery(builder: QueryBuilder, table: string): string {
    return builder
      .select("COUNT(*) as total")
      .from(table)
      .where("active = true")
      .build();
  }
 
  buildSearchQuery(builder: QueryBuilder, table: string, keyword: string): string {
    return builder
      .select("id, name, description")
      .from(table)
      .where(`name LIKE '%${keyword}%'`)
      .where("active = true")
      .orderBy("name", "ASC")
      .limit(50)
      .build();
  }
}
 
// 使用
const director = new QueryDirector();
 
const listQuery = director.buildPaginatedQuery(new SQLQueryBuilder(), "users", 2, 20);
console.log(listQuery);
// SELECT * FROM users WHERE active = true ORDER BY created_at DESC LIMIT 20 OFFSET 20
 
const countQuery = director.buildCountQuery(new SQLQueryBuilder(), "users");
console.log(countQuery);
// SELECT COUNT(*) as total FROM users WHERE active = true

interface UserConfig {
  readonly name: string;
  readonly email: string;
  readonly role: "admin" | "editor" | "viewer";
  readonly notifications: boolean;
  readonly language: string;
  readonly theme: "light" | "dark" | "system";
}
 
class UserConfigBuilder {
  private config: Partial<UserConfig> = {};
 
  setName(name: string): this {
    if (name.trim().length === 0) throw new Error("Name cannot be empty");
    this.config.name = name.trim();
    return this;
  }
 
  setEmail(email: string): this {
    if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
      throw new Error(`Invalid email: ${email}`);
    }
    this.config.email = email.toLowerCase();
    return this;
  }
 
  setRole(role: "admin" | "editor" | "viewer"): this {
    this.config.role = role;
    return this;
  }
 
  enableNotifications(flag: boolean): this {
    this.config.notifications = flag;
    return this;
  }
 
  setLanguage(lang: string): this {
    this.config.language = lang;
    return this;
  }
 
  setTheme(theme: "light" | "dark" | "system"): this {
    this.config.theme = theme;
    return this;
  }
 
  build(): UserConfig {
    // 必須フィールドのバリデーション
    if (!this.config.name) throw new Error("name is required");
    if (!this.config.email) throw new Error("email is required");
 
    // デフォルト値の適用 + Object.freeze で不変性を保証
    return Object.freeze({
      name: this.config.name,
      email: this.config.email,
      role: this.config.role ?? "viewer",
      notifications: this.config.notifications ?? true,
      language: this.config.language ?? "ja",
      theme: this.config.theme ?? "system",
    });
  }
}
 
// 使用
const config = new UserConfigBuilder()
  .setName("太郎")
  .setEmail("taro@example.com")
  .setRole("admin")
  .setTheme("dark")
  .build();
 
console.log(config);
// { name: "太郎", email: "taro@example.com", role: "admin",
//   notifications: true, language: "ja", theme: "dark" }
 
// config.name = "次郎"; // Error: Cannot assign to read only property

// Step 1: name が必須
interface NeedsName {
  setName(name: string): NeedsEmail;
}
// Step 2: email が必須
interface NeedsEmail {
  setEmail(email: string): OptionalFields;
}
// Step 3: 任意フィールド + build
interface OptionalFields {
  setAge(age: number): OptionalFields;
  setRole(role: string): OptionalFields;
  setLanguage(lang: string): OptionalFields;
  build(): Person;
}
 
interface Person {
  name: string;
  email: string;
  age?: number;
  role?: string;
  language?: string;
}
 
class PersonBuilder implements NeedsName, NeedsEmail, OptionalFields {
  private name!: string;
  private email!: string;
  private age?: number;
  private role?: string;
  private language?: string;
 
  static create(): NeedsName {
    return new PersonBuilder();
  }
 
  setName(name: string): NeedsEmail {
    this.name = name;
    return this;
  }
 
  setEmail(email: string): OptionalFields {
    this.email = email;
    return this;
  }
 
  setAge(age: number): OptionalFields {
    this.age = age;
    return this;
  }
 
  setRole(role: string): OptionalFields {
    this.role = role;
    return this;
  }
 
  setLanguage(lang: string): OptionalFields {
    this.language = lang;
    return this;
  }
 
  build(): Person {
    return {
      name: this.name,
      email: this.email,
      age: this.age,
      role: this.role,
      language: this.language,
    };
  }
}
 
// コンパイル時に順序が強制される
const person = PersonBuilder.create()
  .setName("Taro")           // NeedsEmail が返る → setEmail 以外呼べない
  .setEmail("t@example.com") // OptionalFields が返る → 任意フィールドと build が呼べる
  .setAge(30)
  .setRole("engineer")
  .build();
 
// コンパイルエラーの例:
// PersonBuilder.create().setAge(30)           // Error: setAge は NeedsName に存在しない
// PersonBuilder.create().setName("A").build() // Error: build は NeedsEmail に存在しない

from dataclasses import dataclass, field
from typing import Optional
 
@dataclass(frozen=True)
class Pizza:
    """不変の Pizza オブジェクト"""
    size: str
    crust: str
    cheese: bool
    pepperoni: bool
    mushrooms: bool
    extra_toppings: tuple[str, ...]  # tuple で不変性を保証
 
    def description(self) -> str:
        toppings = []
        if self.cheese: toppings.append("チーズ")
        if self.pepperoni: toppings.append("ペパロニ")
        if self.mushrooms: toppings.append("マッシュルーム")
        toppings.extend(self.extra_toppings)
        return f"{self.size} {self.crust} ピザ: {', '.join(toppings)}"
 
class PizzaBuilder:
    """Pizza の段階的構築"""
    def __init__(self, size: str):
        self._size = size
        self._crust = "レギュラー"
        self._cheese = False
        self._pepperoni = False
        self._mushrooms = False
        self._extra: list[str] = []
 
    def crust(self, crust: str) -> "PizzaBuilder":
        self._crust = crust
        return self
 
    def add_cheese(self) -> "PizzaBuilder":
        self._cheese = True
        return self
 
    def add_pepperoni(self) -> "PizzaBuilder":
        self._pepperoni = True
        return self
 
    def add_mushrooms(self) -> "PizzaBuilder":
        self._mushrooms = True
        return self
 
    def add_topping(self, topping: str) -> "PizzaBuilder":
        self._extra.append(topping)
        return self
 
    def build(self) -> Pizza:
        return Pizza(
            size=self._size,
            crust=self._crust,
            cheese=self._cheese,
            pepperoni=self._pepperoni,
            mushrooms=self._mushrooms,
            extra_toppings=tuple(self._extra),  # list → tuple で不変化
        )
 
# 使用
pizza = (PizzaBuilder("Large")
    .crust("シンクラスト")
    .add_cheese()
    .add_pepperoni()
    .add_topping("オリーブ")
    .add_topping("バジル")
    .build())
 
print(pizza.description())
# Large シンクラスト ピザ: チーズ, ペパロニ, オリーブ, バジル

public class NutritionFacts {
    private final int servingSize;   // 必須
    private final int servings;      // 必須
    private final int calories;      // 任意
    private final int fat;           // 任意
    private final int sodium;        // 任意
    private final int carbohydrate;  // 任意
 
    public static class Builder {
        // 必須パラメータ
        private final int servingSize;
        private final int servings;
 
        // 任意パラメータ（デフォルト値で初期化）
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;
        private int carbohydrate = 0;
 
        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }
 
        public Builder calories(int val) {
            if (val < 0) throw new IllegalArgumentException("Calories must be non-negative");
            calories = val;
            return this;
        }
 
        public Builder fat(int val) { fat = val; return this; }
        public Builder sodium(int val) { sodium = val; return this; }
        public Builder carbohydrate(int val) { carbohydrate = val; return this; }
 
        public NutritionFacts build() {
            return new NutritionFacts(this);
        }
    }
 
    private NutritionFacts(Builder builder) {
        servingSize  = builder.servingSize;
        servings     = builder.servings;
        calories     = builder.calories;
        fat          = builder.fat;
        sodium       = builder.sodium;
        carbohydrate = builder.carbohydrate;
    }
}
 
// 使用
NutritionFacts cocaCola = new NutritionFacts.Builder(240, 8)
    .calories(100)
    .sodium(35)
    .carbohydrate(27)
    .build();

package main
 
import (
    "fmt"
    "time"
)
 
type Server struct {
    host         string
    port         int
    timeout      time.Duration
    maxConn      int
    enableTLS    bool
    certFile     string
}
 
// Option は Server の設定を変更する関数型
type Option func(*Server)
 
// 各オプションを関数として定義
func WithPort(port int) Option {
    return func(s *Server) {
        s.port = port
    }
}
 
func WithTimeout(d time.Duration) Option {
    return func(s *Server) {
        s.timeout = d
    }
}
 
func WithMaxConnections(max int) Option {
    return func(s *Server) {
        s.maxConn = max
    }
}
 
func WithTLS(certFile string) Option {
    return func(s *Server) {
        s.enableTLS = true
        s.certFile = certFile
    }
}
 
// コンストラクタ: 必須引数 + 可変長オプション
func NewServer(host string, opts ...Option) *Server {
    // デフォルト値
    s := &Server{
        host:    host,
        port:    8080,
        timeout: 30 * time.Second,
        maxConn: 100,
    }
 
    // オプションを適用
    for _, opt := range opts {
        opt(s)
    }
 
    return s
}
 
func main() {
    // デフォルト設定
    s1 := NewServer("localhost")
    fmt.Printf("Server: %s:%d\n", s1.host, s1.port)
    // Server: localhost:8080
 
    // カスタム設定
    s2 := NewServer("api.example.com",
        WithPort(443),
        WithTimeout(10*time.Second),
        WithMaxConnections(1000),
        WithTLS("/etc/certs/server.pem"),
    )
    fmt.Printf("Server: %s:%d (TLS=%v)\n", s2.host, s2.port, s2.enableTLS)
    // Server: api.example.com:443 (TLS=true)
}

data class ServerConfig(
    val host: String,
    val port: Int = 8080,
    val timeout: Long = 30_000,
    val maxConnections: Int = 100,
    val enableTLS: Boolean = false,
    val certFile: String? = null,
)
 
// Kotlin のデフォルト引数 + 名前付き引数 = Builder 不要
val config1 = ServerConfig(
    host = "localhost",
    port = 3000,
    enableTLS = true,
    certFile = "/etc/certs/server.pem",
)
 
// copy で一部だけ変更（Prototype + Builder の合成）
val config2 = config1.copy(
    host = "api.example.com",
    port = 443,
)
 
println(config2)
// ServerConfig(host=api.example.com, port=443, timeout=30000,
//   maxConnections=100, enableTLS=true, certFile=/etc/certs/server.pem)

// 設定されたフィールドを型レベルで追跡
type BuilderState = {
  name: boolean;
  email: boolean;
};
 
class TypedBuilder<State extends BuilderState = { name: false; email: false }> {
  private data: Record<string, any> = {};
 
  setName(name: string): TypedBuilder<State & { name: true }> {
    this.data.name = name;
    return this as any;
  }
 
  setEmail(email: string): TypedBuilder<State & { email: true }> {
    this.data.email = email;
    return this as any;
  }
 
  setAge(age: number): TypedBuilder<State> {
    this.data.age = age;
    return this as any;
  }
 
  // build は name と email が両方 true の場合のみ呼べる
  build(this: TypedBuilder<{ name: true; email: true }>): Person {
    return this.data as Person;
  }
}
 
// OK: name と email が設定済み
const p1 = new TypedBuilder()
  .setName("Taro")
  .setEmail("t@example.com")
  .setAge(30)
  .build(); // OK
 
// Error: build は name: false の状態では呼べない
// new TypedBuilder().setEmail("t@example.com").build();

// 実務的な例: 電子メール構築
interface Email {
  readonly from: string;
  readonly to: string[];
  readonly cc: string[];
  readonly bcc: string[];
  readonly subject: string;
  readonly body: string;
  readonly isHtml: boolean;
  readonly attachments: ReadonlyArray<{ name: string; content: Buffer }>;
  readonly replyTo?: string;
  readonly priority: "low" | "normal" | "high";
}
 
class EmailBuilder {
  private from = "";
  private to: string[] = [];
  private cc: string[] = [];
  private bcc: string[] = [];
  private subject = "";
  private body = "";
  private isHtml = false;
  private attachments: { name: string; content: Buffer }[] = [];
  private replyTo?: string;
  private priority: "low" | "normal" | "high" = "normal";
 
  setFrom(from: string): this {
    this.from = from;
    return this;
  }
 
  addTo(...recipients: string[]): this {
    this.to.push(...recipients);
    return this;
  }
 
  addCc(...recipients: string[]): this {
    this.cc.push(...recipients);
    return this;
  }
 
  addBcc(...recipients: string[]): this {
    this.bcc.push(...recipients);
    return this;
  }
 
  setSubject(subject: string): this {
    this.subject = subject;
    return this;
  }
 
  setTextBody(body: string): this {
    this.body = body;
    this.isHtml = false;
    return this;
  }
 
  setHtmlBody(html: string): this {
    this.body = html;
    this.isHtml = true;
    return this;
  }
 
  addAttachment(name: string, content: Buffer): this {
    this.attachments.push({ name, content });
    return this;
  }
 
  setReplyTo(email: string): this {
    this.replyTo = email;
    return this;
  }
 
  setPriority(priority: "low" | "normal" | "high"): this {
    this.priority = priority;
    return this;
  }
 
  build(): Email {
    if (!this.from) throw new Error("From is required");
    if (this.to.length === 0) throw new Error("At least one recipient is required");
    if (!this.subject) throw new Error("Subject is required");
    if (!this.body) throw new Error("Body is required");
 
    return Object.freeze({
      from: this.from,
      to: [...this.to],
      cc: [...this.cc],
      bcc: [...this.bcc],
      subject: this.subject,
      body: this.body,
      isHtml: this.isHtml,
      attachments: Object.freeze([...this.attachments]),
      replyTo: this.replyTo,
      priority: this.priority,
    });
  }
}
 
// 使用
const email = new EmailBuilder()
  .setFrom("noreply@example.com")
  .addTo("user1@example.com", "user2@example.com")
  .addCc("manager@example.com")
  .setSubject("Weekly Report")
  .setHtmlBody("<h1>Weekly Report</h1><p>...</p>")
  .setPriority("high")
  .build();

// BAD: build() を忘れて Builder オブジェクトを使ってしまう
const config = new ConfigBuilder()
  .setHost("localhost")
  .setPort(8080);
  // .build() を忘れた！ config は ConfigBuilder 型
 
server.start(config); // 型エラーまたは実行時エラー

// 1. TypeScript の型システムで Builder と Product を明確に区別
//    → server.start() は ServerConfig 型のみ受け付ける
 
// 2. Step Builder で build() を最終ステップに強制
 
// 3. ESLint ルールで Builder 型の変数への代入を警告

// BAD: 同じ Builder インスタンスを再利用
const builder = new UserBuilder().setName("Taro").setEmail("t@example.com");
 
const user1 = builder.setRole("admin").build();
const user2 = builder.setRole("viewer").build();
 
// user2 は admin? viewer? → Builder の内部状態に依存する
// builder.setRole("admin") が builder を変更しているので、
// user2 も admin になる可能性がある

// Builder の build() 後にリセットするか、
// 毎回新しい Builder を生成する
 
// 方法 1: build() でリセット
build(): User {
  const user = new User(this);
  this.reset(); // 内部状態をリセット
  return user;
}
 
// 方法 2: 毎回新しい Builder（推奨）
const user1 = User.builder().setName("Taro").setRole("admin").build();
const user2 = User.builder().setName("Taro").setRole("viewer").build();

// NG: build() を忘れて Builder オブジェクトを使ってしまう
const config = new ConfigBuilder()
  .setHost("localhost")
  .setPort(8080);
  // .build() を忘れた！
 
server.start(config); // 型エラーまたは実行時エラー

// NG: Builder が構築以外の責任を持つ
class OrderBuilder {
  private items: CartItem[] = [];
  private coupon?: string;
 
  addItem(item: CartItem): this {
    this.items.push(item);
    return this;
  }
 
  setCoupon(code: string): this {
    this.coupon = code;
    return this;
  }
 
  build(): Order {
    const order = new Order(this.items);
 
    // NG: ビジネスロジック
    if (this.coupon) {
      const discount = validateCoupon(this.coupon); // クーポン検証
      order.applyDiscount(discount);                 // 割引適用
    }
    order.calculateTax();       // 税計算
    order.calculateShipping();  // 送料計算
    sendNotification(order);    // 通知送信（副作用）
 
    return order;
  }
}

// OK: Builder は構築のみ。ビジネスロジックはドメインサービスに委譲
class OrderBuilder {
  private items: CartItem[] = [];
 
  addItem(item: CartItem): this {
    this.items.push(item);
    return this;
  }
 
  build(): Order {
    if (this.items.length === 0) throw new Error("Order must have items");
    return new Order([...this.items]); // 構築のみ
  }
}
 
// ビジネスロジックはサービスに委譲
class OrderService {
  async processOrder(order: Order, couponCode?: string): Promise<Order> {
    if (couponCode) {
      const discount = await this.couponService.validate(couponCode);
      order.applyDiscount(discount);
    }
    order.tax = this.taxService.calculate(order);
    await this.notificationService.send(order);
    return order;
  }
}

// NG: フィールドが2つしかないのに Builder を使う
class PointBuilder {
  private x = 0;
  private y = 0;
 
  setX(x: number): this { this.x = x; return this; }
  setY(y: number): this { this.y = y; return this; }
  build(): Point { return new Point(this.x, this.y); }
}
 
// 20行のコードが、やりたいことに対して過剰

// OK: コンストラクタで十分
class Point {
  constructor(public readonly x: number, public readonly y: number) {}
}
 
const p = new Point(10, 20);

// === あなたの実装をここに書いてください ===

// === あなたの実装をここに書いてください ===

// === あなたの実装をここに書いてください ===