// Vue 2 风格的响应式（Object.defineProperty）
function reactive(obj) {
  const keys = Object.keys(obj)
  const deps = {} // 依赖收集
  
  keys.forEach(key => {
    deps[key] = []
    let value = obj[key]
    
    Object.defineProperty(obj, key, {
      get() {
        // 收集依赖
        if (currentWatcher) {
          deps[key].push(currentWatcher)
        }
        return value
      },
      set(newValue) {
        value = newValue
        // 触发更新
        deps[key].forEach(watcher => watcher.update())
      }
    })
  })
  
  return obj
}

// 新增属性无法被拦截
const user = reactive({ name: 'Alice' })
user.age = 25 // ❌ age 属性没有被 defineProperty 处理，没有响应式

// 删除属性也无法监听
delete user.name // ❌ 无法触发更新

// 用 Proxy 实现响应式
const user = { name: 'Alice', age: 25 }

const proxy = new Proxy(user, {
  get(target, key, receiver) {
    // 依赖收集...
    console.log(`读取 ${String(key)}`)
    
    // 问题来了：如何返回正确的值？
    // 直觉做法是直接返回 target[key]
    return target[key] // ❌ 有问题！
  },
  
  set(target, key, value, receiver) {
    // 触发更新...
    console.log(`设置 ${String(key)} = ${value}`)
    
    // 直觉做法是直接赋值
    target[key] = value // ⚠️ 可能有问题
    return true
  }
})

// 内部操作 vs Reflect API
// 内部操作：obj.key → 引擎执行 target.[[Get]](key, receiver)
// Reflect：Reflect.get(target, key, receiver)

// 内部操作：obj.key = value → 引擎执行 target.[[Set]](key, value, receiver)
// Reflect：Reflect.set(target, key, value, receiver)

// ✅ 正确的做法：用 Reflect 转发
const proxy = new Proxy(user, {
  get(target, key, receiver) {
    console.log(`读取 ${String(key)}`)
    // Reflect.get 的 receiver 参数会正确传递，保证 getter 的 this 绑定正确
    return Reflect.get(target, key, receiver)
  },
  
  set(target, key, value, receiver) {
    console.log(`设置 ${String(key)} = ${value}`)
    // Reflect.set 返回布尔值，自动反映操作是否成功
    return Reflect.set(target, key, value, receiver)
  }
})

const obj = {}
Object.defineProperty(obj, 'x', { value: 1, writable: false })

// Object.defineProperty — 重复定义会抛出异常
try {
  Object.defineProperty(obj, 'x', { value: 2 }) // ❌ TypeError: Cannot redefine property
} catch (e) {
  console.log('Object 方式抛异常:', e.message)
}

// Reflect.defineProperty — 返回 false，不抛异常
const success = Reflect.defineProperty(obj, 'x', { value: 2 })
console.log(success) // false，不会抛出异常

// Object 方式：需要 try-catch
function defineProperties(obj, props) {
  for (const [key, desc] of Object.entries(props)) {
    try {
      Object.defineProperty(obj, key, desc)
    } catch (e) {
      console.error(`定义属性 ${key} 失败`)
      return false
    }
  }
  return true
}

// Reflect 方式：无需 try-catch
function defineProperties(obj, props) {
  for (const [key, desc] of Object.entries(props)) {
    if (!Reflect.defineProperty(obj, key, desc)) {
      console.error(`定义属性 ${key} 失败`)
      return false
    }
  }
  return true
}

const parent = {
  get name() {
    return this._name.toUpperCase()
  },
  set name(val) {
    this._name = val
  }
}

const child = { _name: 'child' }
Object.setPrototypeOf(child, parent)

// 使用 Object / 直接属性访问
child.name // 'CHILD' — 通过原型链调用 parent 的 getter
// getter 内部 this._name 指向 child，所以返回 'CHILD'

// 但如果想强制让 this 指向另一个对象？
// Object 没有提供这样的能力

// Reflect.get 的 receiver 可以指定 this
Reflect.get(parent, 'name', { _name: 'forced' }) // 'FORCED'
// 相当于：parent.name 被调用，但 getter 内部的 this 指向 receiver 对象

const target = {}
const proxy = new Proxy(target, {
  get(target, key, receiver) {
    // receiver 是触发这个 get 的原始对象（可能是 proxy 本身或其原型链上的对象）
    // 如果直接用 target[key]，getter 的 this 永远指向 target
    // 如果用 Reflect.get(target, key, receiver)，getter 的 this 指向 receiver
    return Reflect.get(target, key, receiver)
  }
})

// Object.defineProperty — target, key, descriptor
Object.defineProperty(obj, 'prop', { value: 1 })

// Reflect.defineProperty — target, key, descriptor（一致）
Reflect.defineProperty(obj, 'prop', { value: 1 })

// 但有些 Object API 的参数顺序不同：
const keys = Object.keys(obj)
const values = Object.values(obj)

// 而 Reflect 的所有方法都是 target 作为第一个参数，保持一致

function Person(name, age) {
  this.name = name
  this.age = age
}

// 传统：new 操作符
const alice = new Person('Alice', 25)

// Reflect.construct
const bob = Reflect.construct(Person, ['Bob', 30])

// Reflect.construct 比 new 多了第三个参数：newTarget
// 用于修改 constructor 的 prototype
function Child(name) {
  this.name = name
}

// 用 Person 的构造函数体，但原型用 Child.prototype
const instance = Reflect.construct(Person, ['Alice', 25], Child)
console.log(instance instanceof Person) // false
console.log(instance instanceof Child)  // true
console.log(instance.name) // 'Alice'
console.log(instance.age)  // 25

const obj = {
  _value: 10,
  get value() {
    return this._value * 2
  }
}

const proxy = new Proxy(obj, {
  get(target, key, receiver) {
    console.log(`读取 ${String(key)}`)
    // ❌ 手动返回值，但不处理 receiver
    return target[key]
  }
})

const child = Object.create(proxy)
child._value = 100

console.log(child.value)
// 读取 value
// 100 * 2 = 200 ❌
// 预期是 child._value * 2 = 200，但触发的是 proxy 的 get
// 实际上 target[key] 中的 target 是 obj，所以 this._value 指向 obj._value
// 结果其实是 10 * 2 = 20，但输出显示 200？？？

// 仔细分析：
// 第一次 proxy.get trap 被触发，key = 'value'
// target[key] → obj.value → obj 的 getter 被调用 → this === obj → obj._value * 2 = 20
// 返回 20... 不对，怎么是 200？

const proxy = new Proxy(obj, {
  get(target, key, receiver) {
    console.log(`读取 ${String(key)}`)
    // ✅ 正确传递 receiver
    return Reflect.get(target, key, receiver)
  }
})

const child = Object.create(proxy)
child._value = 100

console.log(child.value)
// 读取 value
// 200 ✅
// Reflect.get 将 receiver 传递给了 getter，this 指向 child
// child._value * 2 = 200

class Base {
  constructor(name) {
    this.name = name
  }
  
  greet() {
    return `Hello, ${this.name}`
  }
}

class Derived extends Base {
  constructor(name, age) {
    // 传统写法
    super(name)
    this.age = age
  }
}

// 用 Reflect.construct 实现动态继承
function createInstance(Constructor, args, proto) {
  // 使用自定义的原型创建实例
  const instance = Reflect.construct(Constructor, args, proto || Constructor)
  return instance
}

// 动态指定 prototype
function SpecialProto() {}
SpecialProto.prototype.customMethod = function() {
  return 'special method'
}

const obj = createInstance(Base, ['Alice'], SpecialProto)
console.log(obj.name)          // 'Alice'
console.log(obj.customMethod()) // 'special method'
console.log(obj instanceof Base)        // false
console.log(obj instanceof SpecialProto) // true

// 传统方式：Function.prototype.apply
const result1 = Math.max.apply(null, [1, 2, 3])

// ES6 方式：展开运算符
const result2 = Math.max(...[1, 2, 3])

// 但某些场景展开运算符行不通，比如：
// 1. this 上下文需要显式指定
function logger(prefix, message) {
  console.log(`[${prefix}] ${message}`)
}

// 用 Function.prototype.apply — 写法别扭
Function.prototype.apply.call(logger, null, ['INFO', 'hello'])

// 用 Reflect.apply — 简洁直观
Reflect.apply(logger, null, ['INFO', 'hello'])

// 2. 需要控制 this 又不希望展开数组
const context = { count: 0 }
function increment(amount) {
  this.count += amount
  return this.count
}

// Reflect.apply 比 fn.apply 更安全（apply 可能被重写）
Reflect.apply(increment, context, [5])
console.log(context.count) // 5

const sym = Symbol('private')
const obj = {
  name: 'Alice',
  age: 25,
  [sym]: 'secret'
}

// Object.keys — 只返回可枚举字符串键
console.log(Object.keys(obj)) // ['name', 'age']

// Object.getOwnPropertyNames — 返回所有字符串键（包括不可枚举）
console.log(Object.getOwnPropertyNames(obj)) // ['name', 'age']

// Object.getOwnPropertySymbols — 只返回 Symbol 键
console.log(Object.getOwnPropertySymbols(obj)) // [Symbol(private)]

// Reflect.ownKeys — 合并返回所有键
console.log(Reflect.ownKeys(obj)) // ['name', 'age', Symbol(private)]

function deepClone(target) {
  if (target === null || typeof target !== 'object') return target
  
  const clone = Array.isArray(target) ? [] : Object.create(Reflect.getPrototypeOf(target))
  
  // 复制所有属性（包括 Symbol 键和不可枚举属性）
  for (const key of Reflect.ownKeys(target)) {
    const descriptor = Reflect.getOwnPropertyDescriptor(target, key)
    if (descriptor) {
      // 完整复制属性描述符
      Reflect.defineProperty(clone, key, { ...descriptor, value: deepClone(descriptor.value) })
    }
  }
  
  return clone
}

function createAccessController(target) {
  let revoked = false
  
  const handler = {
    get(target, key, receiver) {
      if (revoked) throw new Error('访问已被撤销')
      if (key === 'secret') throw new Error('无权访问 secret 属性')
      return Reflect.get(target, key, receiver)
    },
    
    set(target, key, value, receiver) {
      if (revoked) throw new Error('访问已被撤销')
      if (key === 'unchangeable') {
        console.log('unchangeable 是只读属性')
        return false
      }
      return Reflect.set(target, key, value, receiver)
    },
    
    has(target, key) {
      if (revoked) throw new Error('访问已被撤销')
      return Reflect.has(target, key)
    },
    
    deleteProperty(target, key) {
      if (revoked) throw new Error('访问已被撤销')
      return Reflect.deleteProperty(target, key)
    },
    
    ownKeys(target) {
      if (revoked) throw new Error('访问已被撤销')
      return Reflect.ownKeys(target).filter(key => key !== 'secret')
    }
  }
  
  const { proxy, revoke } = Proxy.revocable(target, handler)
  
  return {
    proxy,
    revoke() {
      revoked = true
      revoke()
    },
    isRevoked: () => revoked
  }
}

// 使用
const controller = createAccessController({
  name: '公开数据',
  secret: '这是秘密',
  unchangeable: '固定值'
})

console.log(controller.proxy.name) // '公开数据'
console.log(controller.proxy.secret) // Error: 无权访问 secret 属性
controller.proxy.unchangeable = '新值' // 'unchangeable 是只读属性'

controller.revoke()
console.log(controller.proxy.name) // Error: 访问已被撤销

// 以为 Reflect 是 Object 的完全替代品
Reflect.keys(obj)     // ❌ TypeError: Reflect.keys is not a function
Reflect.values(obj)   // ❌ TypeError: Reflect.values is not a function
Reflect.assign(target, source) // ❌ TypeError: Reflect.assign is not a function
Reflect.entries(obj)  // ❌ TypeError: Reflect.entries is not a function
Reflect.freeze(obj)   // ❌ TypeError: Reflect.freeze is not a function
Reflect.seal(obj)     // ❌ TypeError: Reflect.seal is not a function

// Reflect 有的方法（13 个）：
Reflect.apply
Reflect.construct
Reflect.defineProperty
Reflect.deleteProperty
Reflect.get
Reflect.getOwnPropertyDescriptor
Reflect.getPrototypeOf
Reflect.has
Reflect.isExtensible
Reflect.ownKeys
Reflect.preventExtensions
Reflect.set
Reflect.setPrototypeOf

// 这些是和 Object 共享的（两者都有，行为略有差异）：
Reflect.getPrototypeOf     → Object.getPrototypeOf
Reflect.setPrototypeOf     → Object.setPrototypeOf
Reflect.getOwnPropertyDescriptor → Object.getOwnPropertyDescriptor
Reflect.defineProperty     → Object.defineProperty
Reflect.isExtensible      → Object.isExtensible
Reflect.preventExtensions → Object.preventExtensions
Reflect.ownKeys           → Object.getOwnPropertyNames + Object.getOwnPropertySymbols

// 这些是 Reflect 独有、Object 没有的：
Reflect.get    (Object 没有等价方法)
Reflect.set    (Object 没有等价方法)
Reflect.has    (Object 没有等价方法)
Reflect.deleteProperty (Object 没有等价方法)
Reflect.apply  (Function.prototype.apply，不是 Object)
Reflect.construct (new 操作符，不是 Object)

const target = { x: 1 }
const val1 = target.x
const val2 = Reflect.get(target, 'x')
// 认为 val1 === val2 永远成立

const target = {
  _secret: 42,
  get secret() {
    return this._secret
  }
}

// 直接访问
console.log(target.secret) // 42 — getter 的 this 指向 target

// Reflect.get 没有 receiver
console.log(Reflect.get(target, 'secret')) // 42 — 等价，this 指向 target

// Reflect.get 指定 receiver
const receiver = { _secret: 100 }
console.log(Reflect.get(target, 'secret', receiver)) // 100 — getter 的 this 指向 receiver

// 当没有 getter 时，两者完全等价
Reflect.get(target, key) === target[key] // true（无 getter）

// 有 getter 但 receiver 是 target 时，等价
Reflect.get(target, key, target) === target[key] // true

// 有 getter 且 receiver 是其他对象时，不等价
Reflect.get(target, key, other) !== target[key] // true，getter 的 this 指向 other

// 错误代码：在 Proxy set handler 中不返回布尔值
const proxy = new Proxy({}, {
  set(target, key, value, receiver) {
    Reflect.set(target, key, value, receiver)
    // ❌ 没有 return！隐式返回 undefined
    // Proxy 的 set handler 必须返回布尔值
    // undefined 会被转型为 false，表示设置失败
  }
})

proxy.x = 1
console.log(proxy.x) // undefined ❌ 设置被拒绝了！

// 在严格模式下这甚至会抛出 TypeError
'use strict'
proxy.x = 1 // TypeError: 'set' returned false for property 'x'

const proxy = new Proxy({}, {
  set(target, key, value, receiver) {
    return Reflect.set(target, key, value, receiver)
    // ✅ 直接返回 Reflect.set 的结果
  }
})

// Reflect.apply 只能用于函数
Reflect.apply('not a function', null, []) // ❌ TypeError

// Reflect.construct 只能用于构造函数
Reflect.construct({}, []) // ❌ TypeError: {}.constructor is not a constructor

// 箭头函数不能作为构造函数，也不能 Reflect.construct
const arrow = () => {}
Reflect.construct(arrow, []) // ❌ TypeError: arrow is not a constructor

import 'core-js/stable/reflect'

// 或单独引入
import 'core-js/es/reflect'

// 最佳实践：Proxy + Reflect 联合使用
const handler = {
  get: Reflect.get,          // 完全转发 get
  set: Reflect.set,          // 完全转发 set
  has: Reflect.has,          // 完全转发 has
  deleteProperty: Reflect.deleteProperty, // 完全转发 deleteProperty
  
  // 或者在 trap 中添加额外逻辑后再转发
  get(target, key, receiver) {
    track(target, key)        // 额外逻辑：依赖收集
    return Reflect.get(target, key, receiver) // 转发默认行为
  }
}

// Object API 会将非对象参数装箱
Object.getPrototypeOf('hello') // String.prototype
Object.getPrototypeOf(42)      // Number.prototype

// Reflect API 对非对象参数直接抛 TypeError
Reflect.getPrototypeOf('hello') // ❌ TypeError: Reflect.getPrototypeOf called on non-object
Reflect.getPrototypeOf(42)      // ❌ TypeError: Reflect.getPrototypeOf called on non-object

// 误区：手动实现转发
const badHandler = {
  get(target, key) {
    // ❌ 手动返回值
    return target[key]
  },
  set(target, key, value) {
    // ❌ 手动赋值，没有返回值
    target[key] = value
  }
}

// 最佳实践：始终通过 Reflect 转发
const goodHandler = {
  get(target, key, receiver) {
    // 前置处理
    if (typeof key === 'string' && key.startsWith('_')) {
      throw new Error('私有属性不可访问')
    }
    // 用 Reflect 转发默认行为
    return Reflect.get(target, key, receiver)
  },
  
  set(target, key, value, receiver) {
    // 前置校验
    if (key === 'id' && typeof value !== 'number') {
      throw new TypeError('id 必须是数字')
    }
    // 用 Reflect 转发默认行为
    return Reflect.set(target, key, value, receiver)
  },
  
  deleteProperty(target, key) {
    // 保护关键属性
    if (key === 'id') {
      console.warn('不能删除 id 属性')
      return false
    }
    return Reflect.deleteProperty(target, key)
  },
  
  has(target, key) {
    // 隐藏私有属性
    if (typeof key === 'string' && key.startsWith('_')) {
      return false
    }
    return Reflect.has(target, key)
  }
}

class Validator {
  constructor(target, rules) {
    return new Proxy(target, {
      set(target, key, value, receiver) {
        const rule = rules[key]
        if (rule) {
          if (rule.type && typeof value !== rule.type) {
            throw new TypeError(`${String(key)} 必须是 ${rule.type} 类型`)
          }
          if (rule.min != null && value < rule.min) {
            throw new RangeError(`${String(key)} 不能小于 ${rule.min}`)
          }
          if (rule.max != null && value > rule.max) {
            throw new RangeError(`${String(key)} 不能大于 ${rule.max}`)
          }
          if (rule.pattern && !rule.pattern.test(value)) {
            throw new Error(`${String(key)} 格式不正确`)
          }
        }
        return Reflect.set(target, key, value, receiver)
      }
    })
  }
}

// 使用
const user = new Validator({
  name: '',
  age: 0,
  email: ''
}, {
  name: { type: 'string', minLength: 1 },
  age: { type: 'number', min: 0, max: 150 },
  email: { type: 'string', pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/ }
})

user.name = 'Alice'     // ✅
user.age = 25            // ✅
user.email = 'alice@example.com' // ✅
user.age = -1            // ❌ RangeError
user.email = 'invalid'   // ❌ Error: 格式不正确

function createObservable(target, onChange) {
  return new Proxy(target, {
    set(target, key, value, receiver) {
      const oldValue = Reflect.get(target, key, receiver)
      const result = Reflect.set(target, key, value, receiver)
      
      if (result && oldValue !== value) {
        onChange({
          type: 'update',
          key,
          oldValue,
          newValue: value,
          target
        })
      }
      
      return result
    },
    
    deleteProperty(target, key) {
      const existed = key in target
      if (existed) {
        const oldValue = Reflect.get(target, key)
        const result = Reflect.deleteProperty(target, key)
        if (result) {
          onChange({
            type: 'delete',
            key,
            oldValue,
            target
          })
        }
        return result
      }
      return true
    },
    
    defineProperty(target, key, descriptor) {
      const result = Reflect.defineProperty(target, key, descriptor)
      if (result) {
        onChange({
          type: 'define',
          key,
          descriptor,
          target
        })
      }
      return result
    }
  })
}

// 使用
const user = { name: 'Alice', age: 25 }
const observed = createObservable(user, (event) => {
  console.log(`[变更] ${event.type} ${String(event.key)}:`, 
    event.oldValue, '→', event.newValue ?? '(已删除)')
})

observed.name = 'Bob'    // [变更] update name: Alice → Bob
observed.age = 26         // [变更] update age: 25 → 26
delete observed.name      // [变更] delete name: Bob → (已删除)

const META_KEY = Symbol('meta')

function defineMeta(target, key, meta) {
  // 获取已有的元数据
  let allMeta = Reflect.getOwnPropertyDescriptor(target, META_KEY)?.value
  if (!allMeta) {
    allMeta = {}
    // 用不可枚举、不可写的方式存储
    Reflect.defineProperty(target, META_KEY, {
      value: allMeta,
      writable: true,
      enumerable: false,
      configurable: false
    })
  }
  
  allMeta[key] = meta
}

function getMeta(target, key) {
  const allMeta = target[META_KEY]
  return allMeta?.[key]
}

// 使用
const obj = {}
defineMeta(obj, 'name', { description: '用户名称', required: true })
defineMeta(obj, 'age', { description: '用户年龄', min: 0, max: 150 })

console.log(Reflect.ownKeys(obj)) // [Symbol(meta)] — meta 键不可枚举但可被 ownKeys 获取
console.log(getMeta(obj, 'name')) // { description: '用户名称', required: true }

// 方法 1：Object.keys（推荐）
const keys = Object.keys(obj)

// 方法 2：组合 Reflect.ownKeys + 过滤
const ownKeys = Reflect.ownKeys(obj)
const enumerableKeys = ownKeys.filter(key => {
  const desc = Reflect.getOwnPropertyDescriptor(obj, key)
  return desc && desc.enumerable
})

// 方法 3：for...in（包括原型链上的可枚举属性）
for (const key in obj) {
  if (Object.hasOwn(obj, key)) {
    // 只处理自有属性
  }
}

// 场景 1：在 Proxy 的 get/set handler 中——永远必须传
const handler = {
  get(target, key, receiver) {
    return Reflect.get(target, key, receiver) // 必须传 receiver
  },
  set(target, key, value, receiver) {
    return Reflect.set(target, key, value, receiver) // 必须传 receiver
  }
}

// 场景 2：对象有 getter/setter 且需要控制 this——必须传
const obj = {
  get data() { return this._data }
}
Reflect.get(obj, 'data', { _data: 'custom' }) // 'custom'

// 场景 3：没有 getter/setter 的普通属性——可以不传
const obj2 = { name: 'Alice' }
Reflect.get(obj2, 'name') // 'Alice' — receiver 不影响结果

// 最佳实践：在 Proxy handler 中始终传递 receiver
// 在其他场景，如果你确定属性没有 getter/setter，可以不传

// core-js 的 Reflect polyfill 实现思路（简化版）
if (typeof Reflect === 'undefined') {
  globalThis.Reflect = {
    get(target, key, receiver) {
      // 基本实现：非严格模式下的属性读取
      const desc = Object.getOwnPropertyDescriptor(target, key)
      if (desc && desc.get) {
        return desc.get.call(receiver || target)
      }
      return target[key]
    },
    set(target, key, value, receiver) {
      const desc = Object.getOwnPropertyDescriptor(target, key)
      if (desc) {
        if (desc.writable === false) return false
        if (desc.set) {
          desc.set.call(receiver || target, value)
          return true
        }
      }
      target[key] = value
      return true
    },
    // ... 其他方法类似
  }
}

const obj = {}
obj[Symbol('c')] = 3
obj['b'] = 2
obj[Symbol('a')] = 4
obj['1'] = 'first'
obj['a'] = 1

console.log(Reflect.ownKeys(obj))
// ['1', 'a', 'b', Symbol(c), Symbol(a)]
// 1. '1' — 整数索引（升序）
// 2. 'a' — 字符串键（创建顺序：b 先于 a? 不对...）
// 实际上创建顺序是：Symbol(c), b, Symbol(a), 1, a
// 按规范：先整数 '1'，然后字符串按创建顺序 'b', 'a'，然后 Symbol 按创建顺序 Symbol(c), Symbol(a)
// 所以结果应该是：['1', 'b', 'a', Symbol(c), Symbol(a)]

const obj = { x: 1 }

// delete 操作符
delete obj.x
// 返回 true/false，但写法是语句不是表达式

// 在表达式中使用 delete
const result = delete obj.x // 可以，但 delete 是语句上下文

// Reflect.deleteProperty
const success = Reflect.deleteProperty(obj, 'x')
// 始终返回布尔值，是纯表达式

// 在严格模式下
'use strict'
delete obj.x // 语法上允许
Reflect.deleteProperty(obj, 'x') // 语法上允许，行为一致

// 主要优势：
// 1. 函数式风格，可以在高阶函数中使用
const keys = ['a', 'b', 'c']
keys.forEach(key => Reflect.deleteProperty(obj, key))

// 2. 不会因为严格模式导致语法解析差异
// 3. 与 Proxy 的 deleteProperty trap 对应