// Cloneable インタフェース
// 自身と同じ型のオブジェクトを返す clone() メソッドを定義
interface Cloneable<T> {
  clone(): T;
}
 
// Shape 基底クラス
class Shape implements Cloneable<Shape> {
  constructor(
    public x: number,
    public y: number,
    public color: string
  ) {}
 
  clone(): Shape {
    // プリミティブのみなので Shallow Copy で十分
    return new Shape(this.x, this.y, this.color);
  }
 
  toString(): string {
    return `Shape(${this.x}, ${this.y}, ${this.color})`;
  }
}
 
// Circle: Shape を拡張
class Circle extends Shape {
  constructor(
    x: number,
    y: number,
    color: string,
    public radius: number
  ) {
    super(x, y, color);
  }
 
  // 戻り値型を Circle に特化（共変戻り値型）
  clone(): Circle {
    return new Circle(this.x, this.y, this.color, this.radius);
  }
 
  toString(): string {
    return `Circle(${this.x}, ${this.y}, ${this.color}, r=${this.radius})`;
  }
}
 
// Rectangle: Shape を拡張
class Rectangle extends Shape {
  constructor(
    x: number,
    y: number,
    color: string,
    public width: number,
    public height: number
  ) {
    super(x, y, color);
  }
 
  clone(): Rectangle {
    return new Rectangle(this.x, this.y, this.color, this.width, this.height);
  }
}
 
// 使用例
const original = new Circle(10, 20, "red", 50);
const copy = original.clone();
copy.color = "blue";
copy.x = 100;
 
console.log(original.toString()); // Circle(10, 20, red, r=50)  — 独立
console.log(copy.toString());     // Circle(100, 20, blue, r=50) — 独立
console.log(original !== copy);   // true — 別インスタンス
console.log(copy instanceof Circle); // true — 型も保持

// === Deep Copy が必要なケース: ネストされたオブジェクト ===
 
class Section {
  constructor(
    public heading: string,
    public content: string,
    public subsections: Section[] = []
  ) {}
 
  clone(): Section {
    return new Section(
      this.heading,
      this.content,
      this.subsections.map(s => s.clone()) // 再帰的に Deep Copy
    );
  }
}
 
class Document implements Cloneable<Document> {
  constructor(
    public title: string,
    public sections: Section[],
    public metadata: Map<string, string> = new Map()
  ) {}
 
  // 方法1: 手動 Deep Copy（推奨: メソッド・型情報を完全に保持）
  clone(): Document {
    const clonedSections = this.sections.map(s => s.clone());
    const clonedMetadata = new Map(this.metadata);
    return new Document(this.title, clonedSections, clonedMetadata);
  }
 
  // 方法2: structuredClone（メソッドが失われる点に注意）
  cloneWithStructuredClone(): Document {
    // 注意: structuredClone はプレーンデータのみコピー
    // クラスメソッド、Map、Set のカスタム処理が失われる場合がある
    const data = structuredClone({
      title: this.title,
      sections: this.sections.map(s => ({
        heading: s.heading,
        content: s.content,
        subsections: s.subsections
      })),
      metadata: Object.fromEntries(this.metadata)
    });
    return new Document(
      data.title,
      data.sections.map(
        (s: any) => new Section(s.heading, s.content, s.subsections)
      ),
      new Map(Object.entries(data.metadata))
    );
  }
 
  // 方法3: JSON.parse/stringify（最もシンプルだが制約あり）
  cloneWithJson(): Document {
    // 制約: Date, Map, Set, undefined, 関数, 循環参照に非対応
    const plain = JSON.parse(JSON.stringify({
      title: this.title,
      sections: this.sections
    }));
    return new Document(
      plain.title,
      plain.sections.map(
        (s: any) => new Section(s.heading, s.content, s.subsections || [])
      )
    );
  }
}
 
// 動作確認
const doc = new Document("Report", [
  new Section("Intro", "Introduction text", [
    new Section("Background", "Background detail")
  ]),
  new Section("Body", "Main content"),
]);
doc.metadata.set("author", "Taro");
doc.metadata.set("version", "1.0");
 
const copy = doc.clone();
copy.sections[0].heading = "Changed Intro";
copy.sections[0].subsections[0].content = "Modified";
copy.metadata.set("version", "2.0");
 
console.log(doc.sections[0].heading);                  // "Intro" — 独立
console.log(doc.sections[0].subsections[0].content);   // "Background detail" — 独立
console.log(doc.metadata.get("version"));              // "1.0" — 独立

// プロトタイプをキーで管理し、必要に応じてクローンを提供するレジストリ
class PrototypeRegistry<T extends Cloneable<T>> {
  private prototypes = new Map<string, T>();
 
  // プロトタイプの登録
  register(key: string, prototype: T): void {
    this.prototypes.set(key, prototype);
  }
 
  // 登録解除
  unregister(key: string): boolean {
    return this.prototypes.delete(key);
  }
 
  // クローンの取得
  create(key: string): T {
    const proto = this.prototypes.get(key);
    if (!proto) {
      throw new Error(
        `Prototype "${key}" not found. Available: ${[...this.prototypes.keys()].join(", ")}`
      );
    }
    return proto.clone();
  }
 
  // 登録済みキー一覧
  keys(): string[] {
    return [...this.prototypes.keys()];
  }
 
  // 登録済みかチェック
  has(key: string): boolean {
    return this.prototypes.has(key);
  }
}
 
// 使用例: 図形のプロトタイプレジストリ
const shapeRegistry = new PrototypeRegistry<Shape>();
 
// デフォルトプロトタイプを登録
shapeRegistry.register("small-red-circle", new Circle(0, 0, "red", 10));
shapeRegistry.register("large-blue-circle", new Circle(0, 0, "blue", 100));
shapeRegistry.register("standard-rect", new Rectangle(0, 0, "gray", 200, 100));
 
// 使用: プロトタイプからクローン生成
const c1 = shapeRegistry.create("small-red-circle");
const c2 = shapeRegistry.create("small-red-circle");
 
console.log(c1 !== c2);          // true — 別インスタンス
console.log(c1.toString());      // Circle(0, 0, red, r=10)
 
// カスタマイズ
c1.x = 50;
c1.y = 100;
console.log(c1.toString());      // Circle(50, 100, red, r=10)

import copy
from dataclasses import dataclass, field
from typing import Self
 
# === 方法1: copy モジュールのデフォルト動作 ===
 
class GameState:
    """ゲームの状態を管理するクラス"""
    def __init__(self, level: int, inventory: list[str], stats: dict[str, int]):
        self.level = level
        self.inventory = inventory
        self.stats = stats
 
    def shallow_clone(self) -> "GameState":
        """浅いコピー: inventory と stats は同じオブジェクトを参照"""
        return copy.copy(self)
 
    def deep_clone(self) -> "GameState":
        """深いコピー: 全てのネストされたオブジェクトも再帰的にコピー"""
        return copy.deepcopy(self)
 
    def __repr__(self) -> str:
        return f"GameState(lv={self.level}, inv={self.inventory}, stats={self.stats})"
 
 
# 動作確認
state = GameState(5, ["sword", "shield"], {"hp": 100, "mp": 50})
 
# 浅いコピーの罠
shallow = state.shallow_clone()
shallow.inventory.append("potion")
print(state.inventory)    # ["sword", "shield", "potion"] ← 元も変わる！
print(shallow.inventory)  # ["sword", "shield", "potion"]
 
# 深いコピーの安全性
state2 = GameState(5, ["sword", "shield"], {"hp": 100, "mp": 50})
deep = state2.deep_clone()
deep.inventory.append("potion")
deep.stats["hp"] = 80
print(state2.inventory)   # ["sword", "shield"] ← 独立
print(state2.stats)       # {"hp": 100, "mp": 50} ← 独立
 
 
# === 方法2: __copy__ / __deepcopy__ のカスタマイズ ===
 
class CachedResource:
    """キャッシュ付きリソース: clone 時にキャッシュはリセットしたい"""
    def __init__(self, url: str, data: dict, cache: dict | None = None):
        self.url = url
        self.data = data
        self._cache = cache or {}
        self._fetch_count = 0
 
    def __copy__(self) -> "CachedResource":
        """浅いコピーをカスタマイズ: キャッシュとカウンタをリセット"""
        new = CachedResource(self.url, self.data)
        new._cache = {}  # キャッシュはリセット
        new._fetch_count = 0
        return new
 
    def __deepcopy__(self, memo: dict) -> "CachedResource":
        """深いコピーをカスタマイズ: data は Deep Copy、キャッシュはリセット"""
        new = CachedResource(
            copy.deepcopy(self.url, memo),
            copy.deepcopy(self.data, memo)
        )
        new._cache = {}
        new._fetch_count = 0
        return new
 
 
resource = CachedResource("https://api.example.com", {"key": "value"}, {"cached": True})
cloned = copy.deepcopy(resource)
print(cloned._cache)        # {} ← キャッシュがリセットされている
print(cloned.data)           # {"key": "value"} ← データはコピーされている
print(resource.data is cloned.data)  # False ← 独立したオブジェクト
 
 
# === 方法3: dataclass + カスタム clone ===
 
@dataclass
class Config:
    """設定クラス（dataclass版）"""
    host: str
    port: int
    options: dict[str, str] = field(default_factory=dict)
 
    def clone(self) -> "Config":
        """Deep Copy で独立したコピーを生成"""
        return Config(
            host=self.host,
            port=self.port,
            options=dict(self.options)  # dict の浅いコピー（値が str なので十分）
        )

// === 方法1: Cloneable インタフェース ===
// 注意: Java の Cloneable は設計上の問題が多く、現在は非推奨の傾向
 
public class Spreadsheet implements Cloneable {
    private String name;
    private List<List<String>> cells;
    private Map<String, String> metadata;
 
    public Spreadsheet(String name, List<List<String>> cells) {
        this.name = name;
        this.cells = cells;
        this.metadata = new HashMap<>();
    }
 
    @Override
    public Spreadsheet clone() {
        try {
            Spreadsheet copy = (Spreadsheet) super.clone();
            // Deep copy of cells（2次元リスト）
            copy.cells = new ArrayList<>();
            for (List<String> row : this.cells) {
                copy.cells.add(new ArrayList<>(row));
            }
            // Deep copy of metadata
            copy.metadata = new HashMap<>(this.metadata);
            return copy;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError("Cloneable を実装しているので到達しない");
        }
    }
}
 
 
// === 方法2: Copy Constructor（推奨） ===
// Effective Java で推奨されている方法
 
public class SpreadsheetV2 {
    private final String name;
    private final List<List<String>> cells;
    private final Map<String, String> metadata;
 
    // 通常のコンストラクタ
    public SpreadsheetV2(String name, List<List<String>> cells) {
        this.name = name;
        this.cells = cells;
        this.metadata = new HashMap<>();
    }
 
    // Copy Constructor
    public SpreadsheetV2(SpreadsheetV2 other) {
        this.name = other.name;
        this.cells = new ArrayList<>();
        for (List<String> row : other.cells) {
            this.cells.add(new ArrayList<>(row));
        }
        this.metadata = new HashMap<>(other.metadata);
    }
 
    // Static Factory Method 形式
    public static SpreadsheetV2 copyOf(SpreadsheetV2 other) {
        return new SpreadsheetV2(other);
    }
}
 
 
// === 方法3: Serialization による Deep Copy ===
import java.io.*;
 
public class DeepCopyUtil {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepCopy(T original) {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(original);
            oos.close();
 
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (T) ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("Deep copy failed", e);
        }
    }
}
 
 
// 使用例
SpreadsheetV2 original = new SpreadsheetV2("Budget", List.of(
    new ArrayList<>(List.of("Item", "Cost")),
    new ArrayList<>(List.of("Server", "500"))
));
 
SpreadsheetV2 copy = new SpreadsheetV2(original); // Copy Constructor
// または
SpreadsheetV2 copy2 = SpreadsheetV2.copyOf(original); // Static Factory

package main
 
import "fmt"
 
// Cloneable インタフェース
type Cloneable[T any] interface {
    Clone() T
}
 
// Shape 構造体
type Shape struct {
    X, Y  int
    Color string
    Tags  []string
}
 
// Clone: Deep Copy を実装
func (s *Shape) Clone() *Shape {
    // Tags スライスを新しくコピー
    tagsCopy := make([]string, len(s.Tags))
    copy(tagsCopy, s.Tags)
 
    return &Shape{
        X:     s.X,
        Y:     s.Y,
        Color: s.Color,
        Tags:  tagsCopy,
    }
}
 
// Circle 構造体
type Circle struct {
    Shape  // 埋め込み
    Radius float64
}
 
// Clone: 埋め込み構造体も含めて Deep Copy
func (c *Circle) Clone() *Circle {
    shapeCopy := c.Shape.Clone()
    return &Circle{
        Shape:  *shapeCopy,
        Radius: c.Radius,
    }
}
 
// Document 構造体（ネストあり）
type Document struct {
    Title    string
    Sections []Section
    Meta     map[string]string
}
 
type Section struct {
    Heading string
    Content string
}
 
func (d *Document) Clone() *Document {
    // Sections の Deep Copy
    sections := make([]Section, len(d.Sections))
    for i, s := range d.Sections {
        sections[i] = Section{
            Heading: s.Heading,
            Content: s.Content,
        }
    }
 
    // Map の Deep Copy
    meta := make(map[string]string, len(d.Meta))
    for k, v := range d.Meta {
        meta[k] = v
    }
 
    return &Document{
        Title:    d.Title,
        Sections: sections,
        Meta:     meta,
    }
}
 
func main() {
    original := &Circle{
        Shape:  Shape{X: 10, Y: 20, Color: "red", Tags: []string{"important"}},
        Radius: 50,
    }
 
    cloned := original.Clone()
    cloned.Color = "blue"
    cloned.Tags = append(cloned.Tags, "modified")
 
    fmt.Println(original.Color, original.Tags) // red [important] — 独立
    fmt.Println(cloned.Color, cloned.Tags)     // blue [important modified]
}

// === 方法1: data class の copy()（Shallow Copy）===
 
data class Address(
    val city: String,
    val street: String
)
 
data class User(
    val name: String,
    val age: Int,
    val address: Address,    // 参照型
    val tags: MutableList<String>  // ミュータブルなコレクション
)
 
fun main() {
    val original = User(
        name = "Taro",
        age = 25,
        address = Address("Tokyo", "Shibuya"),
        tags = mutableListOf("admin", "user")
    )
 
    // data class の copy() は Shallow Copy
    val shallow = original.copy(name = "Jiro")
 
    // Address は不変（val + data class）なので安全
    println(original.address === shallow.address) // true（同じ参照だが不変なので問題なし）
 
    // MutableList は浅いコピーなので危険！
    shallow.tags.add("editor")
    println(original.tags) // [admin, user, editor] ← 元も変わる！
}
 
 
// === 方法2: Deep Copy を手動実装 ===
 
data class UserV2(
    val name: String,
    val age: Int,
    val address: Address,
    val tags: List<String>  // 不変リストにする（設計で解決）
) {
    // Deep Copy メソッド
    fun deepCopy(): UserV2 = UserV2(
        name = this.name,
        age = this.age,
        address = this.address.copy(), // data class の copy() で OK（全フィールドが val String）
        tags = this.tags.toList()      // 新しいリストを生成
    )
}
 
 
// === 方法3: sealed interface + clone ===
 
sealed interface ShapeK {
    fun clone(): ShapeK
}
 
data class CircleK(
    val x: Int,
    val y: Int,
    val radius: Double,
    val color: String
) : ShapeK {
    override fun clone(): CircleK = this.copy()
}
 
data class RectangleK(
    val x: Int,
    val y: Int,
    val width: Int,
    val height: Int,
    val color: String
) : ShapeK {
    override fun clone(): RectangleK = this.copy()
}
 
// 使用例: 多態的なクローン
fun duplicateShapes(shapes: List<ShapeK>): List<ShapeK> {
    return shapes.map { it.clone() }
}

// Prototype を内部的に使う Factory
// クライアントにはファクトリインタフェースだけを公開
 
interface Notification {
  title: string;
  body: string;
  priority: "low" | "medium" | "high";
  channels: string[];
  clone(): Notification;
}
 
class EmailNotification implements Notification {
  constructor(
    public title: string,
    public body: string,
    public priority: "low" | "medium" | "high",
    public channels: string[],
    public templateId: string
  ) {}
 
  clone(): EmailNotification {
    return new EmailNotification(
      this.title,
      this.body,
      this.priority,
      [...this.channels],
      this.templateId
    );
  }
}
 
class SlackNotification implements Notification {
  constructor(
    public title: string,
    public body: string,
    public priority: "low" | "medium" | "high",
    public channels: string[],
    public webhookUrl: string
  ) {}
 
  clone(): SlackNotification {
    return new SlackNotification(
      this.title,
      this.body,
      this.priority,
      [...this.channels],
      this.webhookUrl
    );
  }
}
 
// NotificationFactory: Prototype を内部で管理
class NotificationFactory {
  private prototypes = new Map<string, Notification>();
 
  constructor() {
    // デフォルトテンプレートを登録
    this.prototypes.set("welcome-email", new EmailNotification(
      "Welcome!",
      "Welcome to our service.",
      "medium",
      ["email"],
      "tmpl-welcome-001"
    ));
    this.prototypes.set("alert-slack", new SlackNotification(
      "Alert",
      "System alert detected.",
      "high",
      ["#alerts"],
      "https://hooks.slack.com/xxx"
    ));
  }
 
  // Factory メソッド: Prototype をクローンしてカスタマイズ
  create(type: string, overrides?: Partial<Notification>): Notification {
    const proto = this.prototypes.get(type);
    if (!proto) throw new Error(`Unknown notification type: ${type}`);
 
    const notification = proto.clone();
    if (overrides) {
      Object.assign(notification, overrides);
    }
    return notification;
  }
 
  // 新しいテンプレートを動的に登録
  registerTemplate(name: string, prototype: Notification): void {
    this.prototypes.set(name, prototype);
  }
}
 
// 使用例
const factory = new NotificationFactory();
 
const welcome = factory.create("welcome-email", {
  title: "Welcome, Taro!",
  body: "Your account has been created."
});
 
const alert = factory.create("alert-slack", {
  body: "CPU usage exceeded 90%"
});
 
console.log(welcome); // EmailNotification with customized title/body
console.log(alert);   // SlackNotification with customized body

// エディタの状態をクローンして Undo/Redo スタックに保存
 
interface EditorState {
  content: string;
  cursorPosition: number;
  selections: Array<{ start: number; end: number }>;
  clone(): EditorState;
}
 
class TextEditorState implements EditorState {
  constructor(
    public content: string,
    public cursorPosition: number,
    public selections: Array<{ start: number; end: number }>
  ) {}
 
  clone(): TextEditorState {
    return new TextEditorState(
      this.content,
      this.cursorPosition,
      this.selections.map(s => ({ ...s })) // Deep Copy
    );
  }
}
 
class TextEditor {
  private state: TextEditorState;
  private undoStack: TextEditorState[] = [];
  private redoStack: TextEditorState[] = [];
  private readonly maxHistory = 50;
 
  constructor() {
    this.state = new TextEditorState("", 0, []);
  }
 
  // 状態変更前にクローンを保存
  private saveState(): void {
    this.undoStack.push(this.state.clone());
    if (this.undoStack.length > this.maxHistory) {
      this.undoStack.shift(); // 古い履歴を削除
    }
    this.redoStack = []; // Redo スタックをクリア
  }
 
  type(text: string): void {
    this.saveState();
    const before = this.state.content.slice(0, this.state.cursorPosition);
    const after = this.state.content.slice(this.state.cursorPosition);
    this.state.content = before + text + after;
    this.state.cursorPosition += text.length;
  }
 
  undo(): void {
    if (this.undoStack.length === 0) return;
    this.redoStack.push(this.state.clone());
    this.state = this.undoStack.pop()!;
  }
 
  redo(): void {
    if (this.redoStack.length === 0) return;
    this.undoStack.push(this.state.clone());
    this.state = this.redoStack.pop()!;
  }
 
  getContent(): string {
    return this.state.content;
  }
 
  getCursorPosition(): number {
    return this.state.cursorPosition;
  }
}
 
// 使用例
const editor = new TextEditor();
editor.type("Hello");
editor.type(", World!");
console.log(editor.getContent()); // "Hello, World!"
 
editor.undo();
console.log(editor.getContent()); // "Hello"
 
editor.undo();
console.log(editor.getContent()); // ""
 
editor.redo();
console.log(editor.getContent()); // "Hello"

// 循環参照がある場合の Deep Copy は特別な処理が必要
 
class TreeNode {
  children: TreeNode[] = [];
  parent: TreeNode | null = null;
 
  constructor(public name: string, public value: number) {}
 
  addChild(child: TreeNode): void {
    child.parent = this;
    this.children.push(child);
  }
 
  // 循環参照対応の Deep Copy
  // visited マップで既にクローン済みのノードを追跡
  clone(visited = new Map<TreeNode, TreeNode>()): TreeNode {
    // 既にクローン済みならそれを返す（循環参照の解決）
    if (visited.has(this)) {
      return visited.get(this)!;
    }
 
    // 新しいノードを作成し、visited に登録
    const cloned = new TreeNode(this.name, this.value);
    visited.set(this, cloned);
 
    // 子ノードを再帰的にクローン
    for (const child of this.children) {
      const clonedChild = child.clone(visited);
      clonedChild.parent = cloned;
      cloned.children.push(clonedChild);
    }
 
    return cloned;
  }
 
  toString(indent = 0): string {
    const prefix = "  ".repeat(indent);
    let result = `${prefix}${this.name}(${this.value})`;
    for (const child of this.children) {
      result += "\n" + child.toString(indent + 1);
    }
    return result;
  }
}
 
// 使用例
const root = new TreeNode("root", 0);
const a = new TreeNode("A", 1);
const b = new TreeNode("B", 2);
const c = new TreeNode("C", 3);
 
root.addChild(a);
root.addChild(b);
a.addChild(c);
 
const clonedRoot = root.clone();
clonedRoot.children[0].name = "A-modified";
clonedRoot.children[0].value = 999;
 
console.log(root.toString());
// root(0)
//   A(1)
//     C(3)
//   B(2)
 
console.log(clonedRoot.toString());
// root(0)
//   A-modified(999)  ← 独立
//     C(3)
//   B(2)
 
// 親子関係の確認
console.log(clonedRoot.children[0].parent === clonedRoot); // true
console.log(clonedRoot.children[0].parent === root);       // false（独立）

// NG: Shallow Copy で配列・オブジェクトを共有してしまう
class Config {
  constructor(
    public name: string,
    public plugins: string[],
    public settings: Record<string, unknown>
  ) {}
 
  clone(): Config {
    // Object.assign は Shallow Copy！
    return Object.assign(new Config("", [], {}), this);
    // plugins と settings は同じ参照を共有
  }
}
 
const a = new Config("prod", ["auth", "logger"], { debug: false });
const b = a.clone();
b.plugins.push("cache");
b.settings.debug = true;
 
console.log(a.plugins);        // ["auth", "logger", "cache"] ← 意図しない変更！
console.log(a.settings.debug); // true ← 意図しない変更！

// OK: 参照型フィールドを明示的に Deep Copy
class Config {
  constructor(
    public name: string,
    public plugins: string[],
    public settings: Record<string, unknown>
  ) {}
 
  clone(): Config {
    return new Config(
      this.name,
      [...this.plugins],                    // 配列のスプレッドコピー
      structuredClone(this.settings)        // ネストされたオブジェクトの Deep Copy
    );
  }
}

// NG: clone() がバリデーションをスキップ
class PositiveNumber {
  private value: number;
 
  constructor(value: number) {
    if (value <= 0) throw new Error("Value must be positive");
    this.value = value;
  }
 
  getValue(): number { return this.value; }
 
  clone(): PositiveNumber {
    // Object.create でコンストラクタを迂回
    const copy = Object.create(PositiveNumber.prototype);
    copy.value = this.value;
    return copy;
    // 問題: 将来 value を変更する setter が追加された場合、
    // バリデーションなしでオブジェクトが作成される可能性
  }
}

// OK: コンストラクタ経由で不変条件を維持
class PositiveNumber {
  private value: number;
 
  constructor(value: number) {
    if (value <= 0) throw new Error("Value must be positive");
    this.value = value;
  }
 
  getValue(): number { return this.value; }
 
  clone(): PositiveNumber {
    // コンストラクタを通すことでバリデーションが実行される
    return new PositiveNumber(this.value);
  }
}

// NG: ID もそのままコピー → 一意性が壊れる
class Entity {
  constructor(
    public id: string,     // UUID — 一意であるべき
    public name: string,
    public data: unknown
  ) {}
 
  clone(): Entity {
    return new Entity(this.id, this.name, structuredClone(this.data));
    // id が同じ → データベースで衝突！
  }
}

// OK: clone() で新しい ID を生成
import { randomUUID } from "crypto";
 
class Entity {
  constructor(
    public id: string,
    public name: string,
    public data: unknown
  ) {}
 
  clone(): Entity {
    return new Entity(
      randomUUID(),  // 新しい ID を生成
      this.name,
      structuredClone(this.data)
    );
  }
 
  // 「どのフィールドをコピーし、どのフィールドを新規生成するか」を
  // 明示的に設計することが重要
}

// structuredClone がコピーできないもの
class Example {
  method(): void {}  // 関数 → コピーされない
}
 
const obj = {
  fn: () => "hello",           // ❌ 関数
  symbol: Symbol("id"),        // ❌ Symbol
  dom: document.createElement("div"), // ❌ DOM ノード
  error: new Error("test"),    // ✅ コピー可能
  date: new Date(),            // ✅ コピー可能
  regex: /test/gi,             // ✅ コピー可能
  set: new Set([1, 2, 3]),     // ✅ コピー可能
  arrayBuffer: new ArrayBuffer(8), // ✅ コピー可能
};
 
// クラスインスタンスの場合
const instance = new Example();
const cloned = structuredClone(instance);
console.log(typeof cloned.method); // "undefined" — メソッドが失われる！
console.log(cloned instanceof Example); // false — 型情報も失われる！

class EventEmitterWidget {
  private listeners = new Map<string, Function[]>();
 
  on(event: string, handler: Function): void {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, []);
    }
    this.listeners.get(event)!.push(handler);
  }
 
  // clone() でリスナーはどうするか？
  // 選択肢1: リスナーもコピー → 同じハンドラが2つのオブジェクトで発火
  // 選択肢2: リスナーをリセット → クローン後に再登録が必要
  // 選択肢3: リスナーの浅いコピー → 同じ関数参照を共有（通常はOK）
 
  clone(copyListeners = false): EventEmitterWidget {
    const cloned = new EventEmitterWidget();
    if (copyListeners) {
      for (const [event, handlers] of this.listeners) {
        cloned.listeners.set(event, [...handlers]); // 浅いコピー
      }
    }
    return cloned;
  }
}

// 循環参照があるとスタックオーバーフローを起こす
const a: any = { name: "A" };
const b: any = { name: "B", ref: a };
a.ref = b; // 循環参照
 
// NG: 無限再帰
function naiveDeepCopy(obj: any): any {
  const copy: any = {};
  for (const key of Object.keys(obj)) {
    copy[key] = typeof obj[key] === "object"
      ? naiveDeepCopy(obj[key]) // ← 無限ループ！
      : obj[key];
  }
  return copy;
}
 
// OK: visited マップで循環を検出
function safeDeepCopy(obj: any, visited = new WeakMap()): any {
  if (obj === null || typeof obj !== "object") return obj;
  if (visited.has(obj)) return visited.get(obj); // 既訪問なら返す
 
  const copy: any = Array.isArray(obj) ? [] : {};
  visited.set(obj, copy); // 先に登録（循環参照対策）
 
  for (const key of Object.keys(obj)) {
    copy[key] = safeDeepCopy(obj[key], visited);
  }
  return copy;
}
 
// structuredClone は循環参照を自動で処理する
const cloned = structuredClone(a); // OK！
console.log(cloned.ref.ref === cloned); // true — 循環参照が正しく再現

// JSON.stringify/parse で失われるもの一覧
const original = {
  date: new Date("2024-01-01"),         // → 文字列になる
  undefined: undefined,                  // → 消える
  nan: NaN,                              // → null になる
  infinity: Infinity,                    // → null になる
  regex: /test/g,                        // → {} になる
  set: new Set([1, 2]),                  // → {} になる
  fn: () => "hello",                     // → 消える
  symbol: Symbol("id"),                  // → 消える
  bigint: BigInt(42),                    // → TypeError!
};

// テスト
const circle = new Circle(0, 0, "red", 25);
const clonedCircle = circle.clone();
clonedCircle.color = "blue";
 
console.log(circle.describe());       // "Circle(x=0, y=0, color=red, r=25)"
console.log(clonedCircle.describe()); // "Circle(x=0, y=0, color=blue, r=25)"
console.log(circle !== clonedCircle); // true

// テスト
const registry = new CharacterRegistry();
 
registry.register("warrior", new Character(
  "Warrior Template",
  100, 20,
  ["slash", "block"],
  { weapon: "sword", armor: "plate" }
));
 
const player1 = registry.create("warrior", "Hero Taro");
const player2 = registry.create("warrior", "Hero Jiro");
 
player1.skills.push("charge");
player1.equipment.weapon = "legendary-sword";
 
console.log(player1.name);            // "Hero Taro"
console.log(player2.name);            // "Hero Jiro"
console.log(player1.id !== player2.id); // true
console.log(player1.skills);          // ["slash", "block", "charge"]
console.log(player2.skills);          // ["slash", "block"] ← 独立
console.log(player2.equipment.weapon); // "sword" ← 独立

// テスト
const original = {
  str: "hello",
  num: 42,
  bool: true,
  date: new Date("2024-01-01"),
  regex: /test/gi,
  set: new Set([1, 2, { x: 3 }]),
  arr: [1, [2, [3]]],
  circular: null as any,
};
original.circular = original; // 循環参照
 
const cloned = deepClone(original);
 
console.log(cloned.date instanceof Date);     // true
console.log(cloned.date !== original.date);   // true
console.log(cloned.regex instanceof RegExp);  // true
console.log(cloned.map.get("a")!.nested);     // true
console.log(cloned.map.get("a") !== original.map.get("a")); // true
console.log(cloned.circular === cloned);      // true（循環参照が正しく再現）
console.log(cloned.circular !== original);    // true（独立）