// TypeScript 5.x

class User {
  public name: string // 显式声明 public
  age: number // 默认就是 public

  public constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }

  public greet(): string {
    return `Hello, ${this.name}`
  }
}

const user = new User('张三', 25)
console.log(user.name) // ✅ 可以访问
console.log(user.age) // ✅ 可以访问
user.name = '李四' // ✅ 可以修改

class BankAccount {
  private balance: number

  constructor(initialBalance: number) {
    this.balance = initialBalance
  }

  public deposit(amount: number): void {
    if (amount > 0) {
      this.balance += amount
      this.logTransaction('deposit', amount)
    }
  }

  public withdraw(amount: number): boolean {
    if (amount > 0 && amount <= this.balance) {
      this.balance -= amount
      this.logTransaction('withdraw', amount)
      return true
    }
    return false
  }

  public getBalance(): number {
    return this.balance
  }

  private logTransaction(type: string, amount: number): void {
    console.log(`${type}: ${amount}, Balance: ${this.balance}`)
  }
}

const account = new BankAccount(1000)
account.deposit(500)
// account.balance;  // ❌ 错误：私有属性
// account.logTransaction('test', 100);  // ❌ 错误：私有方法
console.log(account.getBalance()) // ✅ 1500

// TypeScript private（编译时检查）
class A {
  private x: number = 1
}

// ES2022 原生私有字段（运行时强制）
class B {
  #x: number = 1

  getX() {
    return this.#x
  }
}

// 区别：
// 1. TypeScript private 编译后变成普通属性，可被绕过
// 2. # 语法是真正的私有，运行时也无法访问
// 3. # 语法不能与 private 修饰符一起使用

class Animal {
  protected name: string
  protected age: number

  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }

  protected makeSound(): void {
    console.log('Some sound')
  }
}

class Dog extends Animal {
  private breed: string

  constructor(name: string, age: number, breed: string) {
    super(name, age)
    this.breed = breed
  }

  public introduce(): string {
    // ✅ 可以访问 protected 成员
    return `我是 ${this.name}，${this.age} 岁，品种是 ${this.breed}`
  }

  public bark(): void {
    this.makeSound() // ✅ 可以调用 protected 方法
    console.log('汪汪！')
  }
}

const dog = new Dog('旺财', 3, '柴犬')
console.log(dog.introduce())
// dog.name;  // ❌ 错误：protected 成员不能在外部访问
// dog.makeSound();  // ❌ 错误

// 受保护的构造函数，不能直接实例化
class Base {
  protected constructor(public id: string) {}
}

// const base = new Base('1');  // ❌ 错误：构造函数受保护

class Derived extends Base {
  constructor(
    id: string,
    public name: string
  ) {
    super(id) // ✅ 子类可以调用
  }

  static create(id: string, name: string): Derived {
    return new Derived(id, name)
  }
}

const derived = new Derived('1', '测试')
// 或使用工厂方法
const derived2 = Derived.create('2', '测试2')

class Config {
  readonly apiUrl: string
  readonly timeout: number
  readonly version = '1.0.0' // 声明时赋值

  constructor(apiUrl: string, timeout: number) {
    this.apiUrl = apiUrl // 构造函数中赋值
    this.timeout = timeout
  }

  // ❌ 不能在其他方法中赋值
  // updateUrl(url: string) {
  //   this.apiUrl = url;  // 错误
  // }
}

const config = new Config('https://api.example.com', 5000)
// config.apiUrl = 'xxx';  // ❌ 错误：只读属性

class Example {
  readonly prop = 1 // 只读属性

  method() {
    const local = 2 // 常量变量
    // local = 3;  // ❌ 错误
    // this.prop = 3;  // ❌ 错误
  }
}

// readonly 用于属性，const 用于变量
// 两者都表示不可重新赋值

class Counter {
  static count: number = 0
  static readonly MAX_COUNT = 100

  id: number

  constructor() {
    Counter.count++
    this.id = Counter.count
  }

  static getCount(): number {
    return Counter.count
  }

  static reset(): void {
    Counter.count = 0
  }
}

const c1 = new Counter()
const c2 = new Counter()
const c3 = new Counter()

console.log(Counter.count) // 3
console.log(Counter.getCount()) // 3
console.log(c1.id, c2.id, c3.id) // 1, 2, 3

Counter.reset()
console.log(Counter.count) // 0

class Database {
  static connection: Connection
  static isInitialized = false

  // 静态初始化块
  static {
    try {
      Database.connection = createConnection()
      Database.isInitialized = true
      console.log('Database initialized')
    } catch (error) {
      console.error('Failed to initialize database')
    }
  }
}

class Example {
  public readonly id: string
  private readonly secret: string
  protected static count: number = 0

  constructor(id: string, secret: string) {
    this.id = id
    this.secret = secret
    Example.count++
  }

  // 静态私有方法
  private static log(message: string): void {
    console.log(`[Example] ${message}`)
  }

  // 受保护的静态属性
  protected static getCount(): number {
    return Example.count
  }
}

class User {
  constructor(
    public readonly id: string,
    public name: string,
    private password: string,
    protected role: string = 'user'
  ) {}

  checkPassword(input: string): boolean {
    return this.password === input
  }
}

const user = new User('1', '张三', 'secret123')
console.log(user.id) // ✅
console.log(user.name) // ✅
// user.id = '2';  // ❌ readonly
// user.password;  // ❌ private

class Singleton {
  private static instance: Singleton
  private constructor(public value: string) {}

  static getInstance(): Singleton {
    if (!Singleton.instance) {
      Singleton.instance = new Singleton('singleton value')
    }
    return Singleton.instance
  }
}

const s1 = Singleton.getInstance()
const s2 = Singleton.getInstance()
console.log(s1 === s2) // true

class Product {
  private constructor(
    public readonly id: string,
    public readonly name: string,
    public readonly price: number
  ) {}

  static create(name: string, price: number): Product {
    const id = Math.random().toString(36).substr(2, 9)
    return new Product(id, name, price)
  }

  static createFromJson(json: string): Product {
    const data = JSON.parse(json)
    return new Product(data.id, data.name, data.price)
  }
}

const product = Product.create('手机', 5999)
console.log(product.id, product.name, product.price)

class StateMachine {
  private currentState: string
  private readonly transitions: Map<string, string[]>

  constructor(initialState: string) {
    this.currentState = initialState
    this.transitions = new Map()
  }

  addTransition(from: string, to: string): this {
    const existing = this.transitions.get(from) || []
    existing.push(to)
    this.transitions.set(from, existing)
    return this
  }

  transition(to: string): boolean {
    const allowed = this.transitions.get(this.currentState) || []
    if (allowed.includes(to)) {
      this.currentState = to
      return true
    }
    return false
  }

  get state(): string {
    return this.currentState
  }
}

const machine = new StateMachine('idle')
  .addTransition('idle', 'running')
  .addTransition('running', 'paused')
  .addTransition('running', 'stopped')
  .addTransition('paused', 'running')

machine.transition('running') // true
console.log(machine.state) // "running"

class Parent {
  private secret = 'secret'
}

class Child extends Parent {
  reveal() {
    // return this.secret;  // ❌ 错误：不能访问
    return 'Cannot access parent private'
  }
}

class Example {
  instanceProp = 'instance'

  static staticMethod() {
    // console.log(this.instanceProp);  // ❌ 错误
  }

  static staticMethodWithInstance(instance: Example) {
    console.log(instance.instanceProp) // ✅ 通过参数访问
  }
}

class Counter {
  private _count = 0

  get count(): number {
    return this._count
  }

  increment(): void {
    this._count++
  }
}

const counter = new Counter()
console.log(counter.count) // ✅ 可读
// counter.count = 10;  // ❌ 没有 setter，不可写
counter.increment() // ✅ 通过方法修改