// === Subject インタフェース ===
 
interface Image {
  display(): void;
  getSize(): number;
  getFilename(): string;
}
 
// === RealSubject ===
 
class HighResImage implements Image {
  private data: Uint8Array;
 
  constructor(private filename: string) {
    // 重い処理: ファイルを読み込む（コンストラクタで実行）
    console.log(`[HighResImage] Loading ${filename} from disk...`);
    console.log(`[HighResImage] Decoding image data...`);
    this.data = new Uint8Array(10_000_000); // 10MB のバッファ
    console.log(`[HighResImage] ${filename} loaded (${this.data.length} bytes)`);
  }
 
  display(): void {
    console.log(`[HighResImage] Displaying ${this.filename} (${this.data.length} bytes)`);
  }
 
  getSize(): number {
    return this.data.length;
  }
 
  getFilename(): string {
    return this.filename;
  }
}
 
// === Proxy ===
 
class ImageProxy implements Image {
  private real: HighResImage | null = null;
 
  constructor(private filename: string) {
    // Proxy の生成は軽量（ファイル読み込みは行わない）
    console.log(`[ImageProxy] Created proxy for ${filename}`);
  }
 
  private ensureLoaded(): HighResImage {
    if (!this.real) {
      console.log(`[ImageProxy] First access - loading real image...`);
      this.real = new HighResImage(this.filename);
    }
    return this.real;
  }
 
  display(): void {
    this.ensureLoaded().display();
  }
 
  getSize(): number {
    return this.ensureLoaded().getSize();
  }
 
  getFilename(): string {
    // ファイル名はProxyが知っているので、RealSubjectを生成する必要がない
    return this.filename;
  }
}
 
// === 使用例 ===
 
console.log("=== Creating image gallery ===");
const gallery: Image[] = [
  new ImageProxy("photo1.jpg"),
  new ImageProxy("photo2.jpg"),
  new ImageProxy("photo3.jpg"),
  new ImageProxy("photo4.jpg"),
  new ImageProxy("photo5.jpg"),
];
console.log(`Gallery has ${gallery.length} images`);
// 出力: 5 つの Proxy が作られるだけ。画像データは未ロード。
 
console.log("\n=== User scrolls to image 2 ===");
gallery[1].display();
// 出力: photo2.jpg のみロードされる
 
console.log("\n=== User scrolls to image 2 again ===");
gallery[1].display();
// 出力: すでにロード済みなので即座に表示
 
console.log("\n=== Getting filename (no loading needed) ===");
console.log(gallery[3].getFilename());
// 出力: photo4.jpg（ロードなしで返せる）

// === Subject インタフェース ===
 
interface AdminService {
  listUsers(): User[];
  deleteUser(userId: string): void;
  resetDatabase(): void;
  viewAuditLogs(): AuditEntry[];
}
 
interface User {
  id: string;
  name: string;
  role: "viewer" | "editor" | "admin" | "superadmin";
}
 
interface AuditEntry {
  action: string;
  userId: string;
  timestamp: Date;
}
 
// === RealSubject ===
 
class RealAdminService implements AdminService {
  listUsers(): User[] {
    console.log("[RealAdmin] Listing all users");
    return [
      { id: "1", name: "Alice", role: "admin" },
      { id: "2", name: "Bob", role: "viewer" },
    ];
  }
 
  deleteUser(userId: string): void {
    console.log(`[RealAdmin] User ${userId} deleted`);
  }
 
  resetDatabase(): void {
    console.log("[RealAdmin] Database has been reset");
  }
 
  viewAuditLogs(): AuditEntry[] {
    console.log("[RealAdmin] Fetching audit logs");
    return [{ action: "login", userId: "1", timestamp: new Date() }];
  }
}
 
// === Protection Proxy ===
 
type Role = User["role"];
 
// メソッドごとの必要ロールを定義
const REQUIRED_ROLES: Record<keyof AdminService, Role[]> = {
  listUsers: ["viewer", "editor", "admin", "superadmin"],
  deleteUser: ["admin", "superadmin"],
  resetDatabase: ["superadmin"],
  viewAuditLogs: ["admin", "superadmin"],
};
 
class AdminProxy implements AdminService {
  constructor(
    private real: AdminService,
    private currentUser: User,
  ) {
    console.log(`[AdminProxy] Created for user ${currentUser.name} (${currentUser.role})`);
  }
 
  private checkAccess(method: keyof AdminService): void {
    const allowedRoles = REQUIRED_ROLES[method];
    if (!allowedRoles.includes(this.currentUser.role)) {
      const msg = `Access denied: ${method} requires ${allowedRoles.join(" or ")}, ` +
        `but ${this.currentUser.name} has role "${this.currentUser.role}"`;
      console.log(`[AdminProxy] ${msg}`);
      throw new Error(msg);
    }
    console.log(`[AdminProxy] Access granted: ${this.currentUser.name} -> ${method}`);
  }
 
  listUsers(): User[] {
    this.checkAccess("listUsers");
    return this.real.listUsers();
  }
 
  deleteUser(userId: string): void {
    this.checkAccess("deleteUser");
    // 追加チェック: 自分自身は削除できない
    if (userId === this.currentUser.id) {
      throw new Error("Cannot delete yourself");
    }
    this.real.deleteUser(userId);
  }
 
  resetDatabase(): void {
    this.checkAccess("resetDatabase");
    this.real.resetDatabase();
  }
 
  viewAuditLogs(): AuditEntry[] {
    this.checkAccess("viewAuditLogs");
    return this.real.viewAuditLogs();
  }
}
 
// === 使用例 ===
 
const realService = new RealAdminService();
 
// Admin ユーザー
const admin: User = { id: "1", name: "Alice", role: "admin" };
const adminProxy = new AdminProxy(realService, admin);
adminProxy.listUsers();       // OK
adminProxy.deleteUser("2");   // OK
// adminProxy.resetDatabase(); // Error: requires superadmin
 
// Viewer ユーザー
const viewer: User = { id: "2", name: "Bob", role: "viewer" };
const viewerProxy = new AdminProxy(realService, viewer);
viewerProxy.listUsers();      // OK
// viewerProxy.deleteUser("1"); // Error: requires admin or superadmin

// === Subject インタフェース ===
 
interface ApiClient {
  fetchUser(id: string): Promise<User>;
  fetchPosts(userId: string): Promise<Post[]>;
}
 
interface User {
  id: string;
  name: string;
  email: string;
}
 
interface Post {
  id: string;
  title: string;
  content: string;
}
 
// === RealSubject ===
 
class RealApiClient implements ApiClient {
  async fetchUser(id: string): Promise<User> {
    console.log(`[API] GET /users/${id} (network request)`);
    // 実際はHTTPリクエスト
    await new Promise(r => setTimeout(r, 100));
    return { id, name: `User-${id}`, email: `user${id}@example.com` };
  }
 
  async fetchPosts(userId: string): Promise<Post[]> {
    console.log(`[API] GET /users/${userId}/posts (network request)`);
    await new Promise(r => setTimeout(r, 200));
    return [
      { id: "p1", title: "Hello", content: "World" },
    ];
  }
}
 
// === LRU キャッシュ実装 ===
 
class LRUCache<T> {
  private cache = new Map<string, { data: T; expiry: number }>();
 
  constructor(
    private maxSize: number,
    private ttlMs: number,
  ) {}
 
  get(key: string): T | undefined {
    const entry = this.cache.get(key);
    if (!entry) return undefined;
 
    if (Date.now() > entry.expiry) {
      this.cache.delete(key);
      console.log(`[Cache] EXPIRED: ${key}`);
      return undefined;
    }
 
    // LRU: アクセスされたエントリを末尾に移動
    this.cache.delete(key);
    this.cache.set(key, entry);
    console.log(`[Cache] HIT: ${key}`);
    return entry.data;
  }
 
  set(key: string, data: T): void {
    // 容量超過時は最も古いエントリを削除
    if (this.cache.size >= this.maxSize) {
      const oldestKey = this.cache.keys().next().value;
      if (oldestKey) {
        this.cache.delete(oldestKey);
        console.log(`[Cache] EVICTED: ${oldestKey}`);
      }
    }
 
    this.cache.set(key, { data, expiry: Date.now() + this.ttlMs });
    console.log(`[Cache] STORED: ${key} (TTL: ${this.ttlMs}ms)`);
  }
 
  invalidate(key: string): void {
    this.cache.delete(key);
    console.log(`[Cache] INVALIDATED: ${key}`);
  }
 
  clear(): void {
    this.cache.clear();
    console.log(`[Cache] CLEARED`);
  }
 
  get size(): number {
    return this.cache.size;
  }
}
 
// === Cache Proxy ===
 
class CachingApiProxy implements ApiClient {
  private cache: LRUCache<unknown>;
 
  constructor(
    private real: ApiClient,
    maxSize = 100,
    ttlMs = 60_000,
  ) {
    this.cache = new LRUCache(maxSize, ttlMs);
  }
 
  async fetchUser(id: string): Promise<User> {
    const key = `user:${id}`;
    const cached = this.cache.get(key) as User | undefined;
    if (cached) return cached;
 
    const user = await this.real.fetchUser(id);
    this.cache.set(key, user);
    return user;
  }
 
  async fetchPosts(userId: string): Promise<Post[]> {
    const key = `posts:${userId}`;
    const cached = this.cache.get(key) as Post[] | undefined;
    if (cached) return cached;
 
    const posts = await this.real.fetchPosts(userId);
    this.cache.set(key, posts);
    return posts;
  }
 
  /** キャッシュを手動で無効化 */
  invalidateUser(id: string): void {
    this.cache.invalidate(`user:${id}`);
  }
}
 
// === 使用例 ===
 
const api: ApiClient = new CachingApiProxy(new RealApiClient(), 50, 30_000);
 
// 1回目: キャッシュなし → ネットワークリクエスト
const user1 = await api.fetchUser("42");
// 出力: [Cache] key not found
// 出力: [API] GET /users/42 (network request)
// 出力: [Cache] STORED: user:42
 
// 2回目: キャッシュヒット → ネットワークリクエストなし
const user2 = await api.fetchUser("42");
// 出力: [Cache] HIT: user:42

// === ES6 Proxy を使ったバリデーション ===
 
interface UserData {
  name: string;
  age: number;
  email: string;
}
 
type ValidationRule = {
  validate: (value: unknown) => boolean;
  message: string;
};
 
const RULES: Partial<Record<keyof UserData, ValidationRule[]>> = {
  name: [
    { validate: (v) => typeof v === "string", message: "name must be a string" },
    { validate: (v) => (v as string).length >= 2, message: "name must be at least 2 chars" },
    { validate: (v) => (v as string).length <= 50, message: "name must be at most 50 chars" },
  ],
  age: [
    { validate: (v) => typeof v === "number", message: "age must be a number" },
    { validate: (v) => Number.isInteger(v), message: "age must be an integer" },
    { validate: (v) => (v as number) >= 0, message: "age must be non-negative" },
    { validate: (v) => (v as number) <= 150, message: "age must be at most 150" },
  ],
  email: [
    { validate: (v) => typeof v === "string", message: "email must be a string" },
    { validate: (v) => (v as string).includes("@"), message: "email must contain @" },
    { validate: (v) => (v as string).includes("."), message: "email must contain ." },
  ],
};
 
function createValidatedUser(initial: UserData): UserData {
  return new Proxy(initial, {
    set(target, prop: string, value: unknown): boolean {
      const rules = RULES[prop as keyof UserData];
      if (rules) {
        for (const rule of rules) {
          if (!rule.validate(value)) {
            throw new Error(`Validation failed: ${rule.message} (got: ${value})`);
          }
        }
      }
      console.log(`[Proxy] Set ${prop} = ${value}`);
      (target as Record<string, unknown>)[prop] = value;
      return true;
    },
 
    get(target, prop: string): unknown {
      console.log(`[Proxy] Get ${prop}`);
      return (target as Record<string, unknown>)[prop];
    },
 
    deleteProperty(target, prop: string): boolean {
      throw new Error(`Cannot delete property: ${prop}`);
    },
  });
}
 
// === 使用例 ===
 
const user = createValidatedUser({ name: "Taro", age: 30, email: "taro@example.com" });
 
user.name = "Hanako";   // OK
user.age = 25;           // OK
// user.age = -1;        // Error: age must be non-negative
// user.email = "invalid"; // Error: email must contain @
// delete user.name;     // Error: Cannot delete property: name
 
console.log(user.name);  // "Hanako"

// === Vue.js 風のリアクティブシステム ===
 
type Listener = () => void;
 
function reactive<T extends object>(target: T, onChange: Listener): T {
  const handler: ProxyHandler<T> = {
    set(obj: T, prop: string | symbol, value: unknown): boolean {
      const oldValue = (obj as Record<string | symbol, unknown>)[prop];
      if (oldValue !== value) {
        (obj as Record<string | symbol, unknown>)[prop] = value;
        console.log(`[Reactive] ${String(prop)}: ${String(oldValue)} -> ${String(value)}`);
        onChange();
      }
      return true;
    },
 
    get(obj: T, prop: string | symbol): unknown {
      const value = (obj as Record<string | symbol, unknown>)[prop];
      // ネストされたオブジェクトも再帰的にリアクティブ化
      if (value && typeof value === "object" && !Array.isArray(value)) {
        return reactive(value as object, onChange);
      }
      return value;
    },
  };
 
  return new Proxy(target, handler);
}
 
// === 使用例 ===
 
interface AppState {
  count: number;
  user: {
    name: string;
    settings: {
      theme: string;
    };
  };
}
 
let renderCount = 0;
const state = reactive<AppState>(
  {
    count: 0,
    user: {
      name: "Taro",
      settings: { theme: "light" },
    },
  },
  () => {
    renderCount++;
    console.log(`[App] Re-render #${renderCount}`);
  },
);
 
state.count = 1;
// 出力: [Reactive] count: 0 -> 1
// 出力: [App] Re-render #1
 
state.user.name = "Hanako";
// 出力: [Reactive] name: Taro -> Hanako
// 出力: [App] Re-render #2
 
state.user.settings.theme = "dark";
// 出力: [Reactive] theme: light -> dark
// 出力: [App] Re-render #3
 
state.count = 1; // 同じ値 → 変更なし → 再レンダリングなし

// === 汎用 Logging Proxy ファクトリ ===
 
interface LogEntry {
  method: string;
  args: unknown[];
  result?: unknown;
  error?: string;
  durationMs: number;
  timestamp: Date;
}
 
function createLoggingProxy<T extends object>(
  target: T,
  options: {
    name?: string;
    logArgs?: boolean;
    logResult?: boolean;
    onLog?: (entry: LogEntry) => void;
  } = {},
): T {
  const {
    name = target.constructor.name,
    logArgs = true,
    logResult = false,
    onLog = (entry) => {
      const argsStr = logArgs ? `(${entry.args.map(a => JSON.stringify(a)).join(", ")})` : "(...)";
      const resultStr = logResult && entry.result !== undefined ? ` -> ${JSON.stringify(entry.result)}` : "";
      const errorStr = entry.error ? ` ERROR: ${entry.error}` : "";
      console.log(
        `[${name}] ${entry.method}${argsStr}${resultStr}${errorStr} [${entry.durationMs}ms]`
      );
    },
  } = options;
 
  return new Proxy(target, {
    get(obj, prop) {
      const value = (obj as Record<string | symbol, unknown>)[prop];
      if (typeof value !== "function") return value;
 
      return function (this: unknown, ...args: unknown[]) {
        const start = performance.now();
        const entry: LogEntry = {
          method: String(prop),
          args,
          durationMs: 0,
          timestamp: new Date(),
        };
 
        try {
          const result = (value as Function).apply(obj, args);
 
          // Promise を検知して非同期もトレース
          if (result instanceof Promise) {
            return result
              .then((resolved: unknown) => {
                entry.result = resolved;
                entry.durationMs = Math.round(performance.now() - start);
                onLog(entry);
                return resolved;
              })
              .catch((err: Error) => {
                entry.error = err.message;
                entry.durationMs = Math.round(performance.now() - start);
                onLog(entry);
                throw err;
              });
          }
 
          entry.result = result;
          entry.durationMs = Math.round(performance.now() - start);
          onLog(entry);
          return result;
        } catch (err) {
          entry.error = (err as Error).message;
          entry.durationMs = Math.round(performance.now() - start);
          onLog(entry);
          throw err;
        }
      };
    },
  });
}
 
// === 使用例 ===
 
class UserRepository {
  findById(id: string): User | null {
    return { id, name: `User-${id}`, email: `${id}@example.com` };
  }
 
  async save(user: User): Promise<void> {
    await new Promise(r => setTimeout(r, 50));
  }
 
  delete(id: string): void {
    throw new Error("Not implemented");
  }
}
 
const repo = createLoggingProxy(new UserRepository(), {
  name: "UserRepo",
  logResult: true,
});
 
repo.findById("42");
// 出力: [UserRepo] findById("42") -> {"id":"42","name":"User-42",...} [0ms]
 
await repo.save({ id: "1", name: "New", email: "new@example.com" });
// 出力: [UserRepo] save({"id":"1",...}) [51ms]
 
try {
  repo.delete("1");
} catch (e) {
  // 出力: [UserRepo] delete("1") ERROR: Not implemented [0ms]
}

from abc import ABC, abstractmethod
import time
import functools
from typing import Any, Callable
 
 
# === Subject ===
 
class Database(ABC):
    @abstractmethod
    def query(self, sql: str) -> list[dict]: ...
 
    @abstractmethod
    def execute(self, sql: str) -> int: ...
 
 
class PostgresDatabase(Database):
    def query(self, sql: str) -> list[dict]:
        time.sleep(0.05)  # ネットワーク遅延のシミュレーション
        print(f"[Postgres] Executing query: {sql}")
        return [{"id": 1, "name": "Taro"}]
 
    def execute(self, sql: str) -> int:
        time.sleep(0.05)
        print(f"[Postgres] Executing: {sql}")
        return 1  # affected rows
 
 
# === Logging Proxy ===
 
class LoggingProxy:
    """__getattr__ を使った汎用 Logging Proxy"""
 
    def __init__(self, target: Any, name: str = ""):
        self._target = target
        self._name = name or type(target).__name__
 
    def __getattr__(self, attr: str) -> Any:
        original = getattr(self._target, attr)
 
        if not callable(original):
            return original
 
        @functools.wraps(original)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            args_str = ", ".join(
                [repr(a) for a in args] +
                [f"{k}={v!r}" for k, v in kwargs.items()]
            )
            print(f"[{self._name}] {attr}({args_str})")
 
            start = time.perf_counter()
            try:
                result = original(*args, **kwargs)
                elapsed = (time.perf_counter() - start) * 1000
                print(f"[{self._name}] {attr} -> {result!r} [{elapsed:.1f}ms]")
                return result
            except Exception as e:
                elapsed = (time.perf_counter() - start) * 1000
                print(f"[{self._name}] {attr} ERROR: {e} [{elapsed:.1f}ms]")
                raise
 
        return wrapper
 
 
# === Cache Proxy ===
 
class CachingProxy:
    """TTL 付きキャッシュ Proxy"""
 
    def __init__(self, target: Any, ttl: float = 60.0):
        self._target = target
        self._ttl = ttl
        self._cache: dict[str, tuple[Any, float]] = {}
 
    def __getattr__(self, attr: str) -> Any:
        original = getattr(self._target, attr)
 
        if not callable(original):
            return original
 
        @functools.wraps(original)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            key = f"{attr}:{args!r}:{kwargs!r}"
 
            # キャッシュチェック
            if key in self._cache:
                result, expiry = self._cache[key]
                if time.time() < expiry:
                    print(f"[Cache] HIT: {key[:50]}")
                    return result
                else:
                    del self._cache[key]
                    print(f"[Cache] EXPIRED: {key[:50]}")
 
            print(f"[Cache] MISS: {key[:50]}")
            result = original(*args, **kwargs)
            self._cache[key] = (result, time.time() + self._ttl)
            return result
 
        return wrapper
 
 
# === Proxy チェーン ===
 
db: Database = PostgresDatabase()
db = CachingProxy(db, ttl=30.0)   # キャッシュ層
db = LoggingProxy(db, "DB")        # ログ層
 
# 1回目: キャッシュミス → DB アクセス
result = db.query("SELECT * FROM users")
# 出力:
# [DB] query('SELECT * FROM users')
# [Cache] MISS: query:('SELECT * FROM users',):{}
# [Postgres] Executing query: SELECT * FROM users
# [DB] query -> [{'id': 1, 'name': 'Taro'}] [52.3ms]
 
# 2回目: キャッシュヒット
result = db.query("SELECT * FROM users")
# 出力:
# [DB] query('SELECT * FROM users')
# [Cache] HIT: query:('SELECT * FROM users',):{}
# [DB] query -> [{'id': 1, 'name': 'Taro'}] [0.1ms]

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.*;
 
// === Subject インタフェース ===
 
interface UserService {
    User findById(String id);
    List<User> findAll();
    void delete(String id);
}
 
record User(String id, String name, String email) {}
 
// === RealSubject ===
 
class UserServiceImpl implements UserService {
    @Override
    public User findById(String id) {
        System.out.println("[UserService] findById: " + id);
        return new User(id, "User-" + id, id + "@example.com");
    }
 
    @Override
    public List<User> findAll() {
        System.out.println("[UserService] findAll");
        return List.of(
            new User("1", "Alice", "alice@example.com"),
            new User("2", "Bob", "bob@example.com")
        );
    }
 
    @Override
    public void delete(String id) {
        System.out.println("[UserService] delete: " + id);
    }
}
 
// === 動的 Proxy (InvocationHandler) ===
 
class LoggingHandler implements InvocationHandler {
    private final Object target;
 
    LoggingHandler(Object target) {
        this.target = target;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String argsStr = args != null ? Arrays.toString(args) : "()";
        System.out.printf("[Log] %s.%s%s%n",
            target.getClass().getSimpleName(), method.getName(), argsStr);
 
        long start = System.nanoTime();
        try {
            Object result = method.invoke(target, args);
            long elapsed = (System.nanoTime() - start) / 1_000_000;
            System.out.printf("[Log] %s returned in %dms%n", method.getName(), elapsed);
            return result;
        } catch (Exception e) {
            long elapsed = (System.nanoTime() - start) / 1_000_000;
            System.out.printf("[Log] %s FAILED in %dms: %s%n",
                method.getName(), elapsed, e.getMessage());
            throw e.getCause();
        }
    }
}
 
class CachingHandler implements InvocationHandler {
    private final Object target;
    private final Map<String, Object> cache = new HashMap<>();
 
    CachingHandler(Object target) {
        this.target = target;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // void メソッドはキャッシュしない
        if (method.getReturnType() == void.class) {
            return method.invoke(target, args);
        }
 
        String key = method.getName() + ":" + Arrays.toString(args);
        if (cache.containsKey(key)) {
            System.out.println("[Cache] HIT: " + key);
            return cache.get(key);
        }
 
        System.out.println("[Cache] MISS: " + key);
        Object result = method.invoke(target, args);
        cache.put(key, result);
        return result;
    }
}
 
// === 動的 Proxy ファクトリ ===
 
class ProxyFactory {
    @SuppressWarnings("unchecked")
    static <T> T createLoggingProxy(T target, Class<T> iface) {
        return (T) Proxy.newProxyInstance(
            iface.getClassLoader(),
            new Class[]{iface},
            new LoggingHandler(target)
        );
    }
 
    @SuppressWarnings("unchecked")
    static <T> T createCachingProxy(T target, Class<T> iface) {
        return (T) Proxy.newProxyInstance(
            iface.getClassLoader(),
            new Class[]{iface},
            new CachingHandler(target)
        );
    }
}
 
// === 使用例 ===
 
public class Main {
    public static void main(String[] args) {
        UserService real = new UserServiceImpl();
 
        // キャッシュ + ログの Proxy チェーン
        UserService cached = ProxyFactory.createCachingProxy(real, UserService.class);
        UserService logged = ProxyFactory.createLoggingProxy(cached, UserService.class);
 
        logged.findById("42");
        // [Log] $Proxy.findById[42]
        // [Cache] MISS: findById:[42]
        // [UserService] findById: 42
        // [Log] findById returned in 1ms
 
        logged.findById("42");
        // [Log] $Proxy.findById[42]
        // [Cache] HIT: findById:[42]
        // [Log] findById returned in 0ms
    }
}

package main
 
import (
    "context"
    "fmt"
    "sync"
    "time"
)
 
// === Subject インタフェース ===
 
type Storage interface {
    Get(ctx context.Context, key string) (string, error)
    Set(ctx context.Context, key string, value string) error
    Delete(ctx context.Context, key string) error
}
 
// === RealSubject ===
 
type RedisStorage struct {
    data map[string]string
    mu   sync.RWMutex
}
 
func NewRedisStorage() *RedisStorage {
    return &RedisStorage{data: make(map[string]string)}
}
 
func (r *RedisStorage) Get(ctx context.Context, key string) (string, error) {
    r.mu.RLock()
    defer r.mu.RUnlock()
    time.Sleep(10 * time.Millisecond) // ネットワーク遅延
    val, ok := r.data[key]
    if !ok {
        return "", fmt.Errorf("key not found: %s", key)
    }
    fmt.Printf("[Redis] GET %s -> %s\n", key, val)
    return val, nil
}
 
func (r *RedisStorage) Set(ctx context.Context, key string, value string) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    time.Sleep(10 * time.Millisecond)
    r.data[key] = value
    fmt.Printf("[Redis] SET %s = %s\n", key, value)
    return nil
}
 
func (r *RedisStorage) Delete(ctx context.Context, key string) error {
    r.mu.Lock()
    defer r.mu.Unlock()
    delete(r.data, key)
    fmt.Printf("[Redis] DEL %s\n", key)
    return nil
}
 
// === Logging Proxy ===
 
type LoggingStorage struct {
    inner Storage
}
 
func NewLoggingStorage(inner Storage) *LoggingStorage {
    return &LoggingStorage{inner: inner}
}
 
func (l *LoggingStorage) Get(ctx context.Context, key string) (string, error) {
    start := time.Now()
    val, err := l.inner.Get(ctx, key)
    elapsed := time.Since(start)
    if err != nil {
        fmt.Printf("[Log] GET %s ERROR: %v [%v]\n", key, err, elapsed)
    } else {
        fmt.Printf("[Log] GET %s -> %s [%v]\n", key, val, elapsed)
    }
    return val, err
}
 
func (l *LoggingStorage) Set(ctx context.Context, key string, value string) error {
    start := time.Now()
    err := l.inner.Set(ctx, key, value)
    elapsed := time.Since(start)
    fmt.Printf("[Log] SET %s = %s [%v]\n", key, value, elapsed)
    return err
}
 
func (l *LoggingStorage) Delete(ctx context.Context, key string) error {
    start := time.Now()
    err := l.inner.Delete(ctx, key)
    elapsed := time.Since(start)
    fmt.Printf("[Log] DEL %s [%v]\n", key, elapsed)
    return err
}
 
// === Circuit Breaker Proxy ===
 
type CircuitState int
 
const (
    Closed CircuitState = iota
    Open
    HalfOpen
)
 
type CircuitBreakerStorage struct {
    inner        Storage
    state        CircuitState
    failures     int
    threshold    int
    resetTimeout time.Duration
    lastFailure  time.Time
    mu           sync.Mutex
}
 
func NewCircuitBreakerStorage(inner Storage, threshold int, resetTimeout time.Duration) *CircuitBreakerStorage {
    return &CircuitBreakerStorage{
        inner:        inner,
        state:        Closed,
        threshold:    threshold,
        resetTimeout: resetTimeout,
    }
}
 
func (cb *CircuitBreakerStorage) canExecute() bool {
    cb.mu.Lock()
    defer cb.mu.Unlock()
 
    switch cb.state {
    case Closed:
        return true
    case Open:
        if time.Since(cb.lastFailure) > cb.resetTimeout {
            cb.state = HalfOpen
            fmt.Println("[CB] State: Open -> HalfOpen")
            return true
        }
        return false
    case HalfOpen:
        return true
    }
    return false
}
 
func (cb *CircuitBreakerStorage) recordSuccess() {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    cb.failures = 0
    if cb.state == HalfOpen {
        cb.state = Closed
        fmt.Println("[CB] State: HalfOpen -> Closed")
    }
}
 
func (cb *CircuitBreakerStorage) recordFailure() {
    cb.mu.Lock()
    defer cb.mu.Unlock()
    cb.failures++
    cb.lastFailure = time.Now()
    if cb.failures >= cb.threshold {
        cb.state = Open
        fmt.Printf("[CB] State: -> Open (failures: %d)\n", cb.failures)
    }
}
 
func (cb *CircuitBreakerStorage) Get(ctx context.Context, key string) (string, error) {
    if !cb.canExecute() {
        return "", fmt.Errorf("circuit breaker is OPEN")
    }
    val, err := cb.inner.Get(ctx, key)
    if err != nil {
        cb.recordFailure()
    } else {
        cb.recordSuccess()
    }
    return val, err
}
 
func (cb *CircuitBreakerStorage) Set(ctx context.Context, key string, value string) error {
    if !cb.canExecute() {
        return fmt.Errorf("circuit breaker is OPEN")
    }
    err := cb.inner.Set(ctx, key, value)
    if err != nil {
        cb.recordFailure()
    } else {
        cb.recordSuccess()
    }
    return err
}
 
func (cb *CircuitBreakerStorage) Delete(ctx context.Context, key string) error {
    if !cb.canExecute() {
        return fmt.Errorf("circuit breaker is OPEN")
    }
    err := cb.inner.Delete(ctx, key)
    if err != nil {
        cb.recordFailure()
    } else {
        cb.recordSuccess()
    }
    return err
}
 
// === 使用例 ===
 
func main() {
    ctx := context.Background()
 
    // Proxy チェーン: Redis -> CircuitBreaker -> Logging
    var storage Storage = NewRedisStorage()
    storage = NewCircuitBreakerStorage(storage, 3, 30*time.Second)
    storage = NewLoggingStorage(storage)
 
    storage.Set(ctx, "user:1", "Alice")
    storage.Get(ctx, "user:1")
}

import kotlin.properties.ReadWriteProperty
import kotlin.reflect.KProperty
 
// === Kotlin の Property Delegation は Proxy パターン ===
 
class LoggedProperty<T>(
    private var value: T,
    private val name: String,
) : ReadWriteProperty<Any?, T> {
 
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        println("[Log] Reading $name = $value")
        return value
    }
 
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        val old = this.value
        this.value = value
        println("[Log] Writing $name: $old -> $value")
    }
}
 
class ValidatedProperty<T>(
    private var value: T,
    private val validator: (T) -> Boolean,
    private val errorMessage: String,
) : ReadWriteProperty<Any?, T> {
 
    override fun getValue(thisRef: Any?, property: KProperty<*>): T = value
 
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        if (!validator(value)) {
            throw IllegalArgumentException("$errorMessage (got: $value)")
        }
        this.value = value
    }
}
 
// === LazyProxy: Virtual Proxy as Property Delegate ===
 
class LazyProxy<T>(
    private val factory: () -> T,
) : ReadWriteProperty<Any?, T> {
    private var instance: T? = null
    private var overridden = false
    private var overriddenValue: T? = null
 
    override fun getValue(thisRef: Any?, property: KProperty<*>): T {
        if (overridden) {
            @Suppress("UNCHECKED_CAST")
            return overriddenValue as T
        }
        if (instance == null) {
            println("[LazyProxy] Creating ${property.name}")
            instance = factory()
        }
        return instance!!
    }
 
    override fun setValue(thisRef: Any?, property: KProperty<*>, value: T) {
        overridden = true
        overriddenValue = value
    }
}
 
// === 使用例 ===
 
class UserProfile {
    var name: String by LoggedProperty("", "name")
    var age: Int by ValidatedProperty(0, { it in 0..150 }, "Age must be 0-150")
    var email: String by ValidatedProperty("", { "@" in it }, "Invalid email")
 
    // 重いリソースの遅延読み込み
    var avatar: ByteArray by LazyProxy {
        println("[LazyProxy] Loading avatar from storage...")
        ByteArray(1_000_000) // 1MB
    }
}
 
fun main() {
    val profile = UserProfile()
 
    profile.name = "Taro"
    // [Log] Writing name:  -> Taro
 
    println(profile.name)
    // [Log] Reading name = Taro
    // Taro
 
    profile.age = 25  // OK
    // profile.age = -1 // IllegalArgumentException
 
    profile.email = "taro@example.com" // OK
    // profile.email = "invalid" // IllegalArgumentException
 
    // avatar はアクセスするまでロードされない
    println("Profile created, avatar not loaded yet")
    val size = profile.avatar.size
    // [LazyProxy] Creating avatar
    // [LazyProxy] Loading avatar from storage...
    println("Avatar size: $size")
}

// NG: Proxy が具象クラスに直接依存し、new で生成
class BadProxy {
  private real = new SpecificDatabaseService("localhost", 5432); // 直接 new
 
  query(sql: string): Result {
    console.log("Logging:", sql);
    return this.real.query(sql); // インタフェースなし
  }
}
 
// 問題:
// 1. SpecificDatabaseService を差し替えられない
// 2. テストでモックに差し替えられない
// 3. Proxy が RealSubject のコンストラクタ引数を知る必要がある

// OK: インタフェース経由で依存し、DI で注入
 
interface DatabaseService {
  query(sql: string): Result;
}
 
class LoggingProxy implements DatabaseService {
  constructor(private real: DatabaseService) {} // DI
 
  query(sql: string): Result {
    console.log("Logging:", sql);
    return this.real.query(sql);
  }
}
 
// テスト
const mockDb: DatabaseService = { query: jest.fn() };
const proxy = new LoggingProxy(mockDb);

// NG: キャッシュ + 認証 + ログ + レート制限を 1 つの Proxy で
class GodProxy implements Service {
  private cache = new Map();
  private requestCount = 0;
 
  doSomething(args: unknown): Result {
    // 認証チェック
    if (!this.currentUser.isAdmin) throw new Error("Access denied");
 
    // レート制限
    this.requestCount++;
    if (this.requestCount > 100) throw new Error("Rate limited");
 
    // キャッシュ
    const key = JSON.stringify(args);
    if (this.cache.has(key)) return this.cache.get(key);
 
    // ログ
    console.log(`[${new Date().toISOString()}] doSomething called`);
 
    // 実行
    const result = this.real.doSomething(args);
    this.cache.set(key, result);
    return result;
  }
}
 
// 問題:
// 1. SRP 違反: 4 つの責務が混在
// 2. テストが困難（すべての責務をテストする必要がある）
// 3. 責務の組み合わせを変更できない

// OK: 責務ごとに Proxy を分離し、チェーンする
 
class AuthProxy implements Service {
  constructor(private real: Service, private user: User) {}
  doSomething(args: unknown): Result {
    if (!this.user.isAdmin) throw new Error("Access denied");
    return this.real.doSomething(args);
  }
}
 
class RateLimitProxy implements Service {
  private count = 0;
  constructor(private real: Service, private limit: number) {}
  doSomething(args: unknown): Result {
    if (++this.count > this.limit) throw new Error("Rate limited");
    return this.real.doSomething(args);
  }
}
 
class CacheProxy implements Service {
  private cache = new Map();
  constructor(private real: Service) {}
  doSomething(args: unknown): Result {
    const key = JSON.stringify(args);
    if (this.cache.has(key)) return this.cache.get(key);
    const result = this.real.doSomething(args);
    this.cache.set(key, result);
    return result;
  }
}
 
class LogProxy implements Service {
  constructor(private real: Service) {}
  doSomething(args: unknown): Result {
    console.log(`[${new Date().toISOString()}] doSomething called`);
    return this.real.doSomething(args);
  }
}
 
// チェーン: Auth -> RateLimit -> Cache -> Log -> Real
const service: Service =
  new AuthProxy(
    new RateLimitProxy(
      new CacheProxy(
        new LogProxy(realService),
      ),
      100,
    ),
    currentUser,
  );