const user = { name: 'Alice', age: 28 };

// Proxy 拦截器：监控属性读写
const userProxy = new Proxy(user, {
  get(target, propKey, receiver) {
    // 自定义逻辑：打印读取日志
    console.log(`正在读取属性：${propKey}`);

    // 用 Reflect.get 执行默认读操作（正确传递 this）
    return Reflect.get(target, propKey, receiver);
  },
  set(target, propKey, value, receiver) {
    // 自定义逻辑：验证 age 必须是正数
    if (propKey === 'age' && value < 0) {
      throw new Error('年龄不能为负数！');
    }

    // 用 Reflect.set 执行默认写操作（返回布尔值表示成功）
    return Reflect.set(target, propKey, value, receiver);
  },
});

// 测试：触发拦截逻辑，同时保持默认行为
console.log(userProxy.name); // 打印“正在读取属性：name”，输出“Alice”
userProxy.age = 30; // 成功设置（无错误）
userProxy.age = -5; // 抛出错误：年龄不能为负数！

const obj = Object.preventExtensions({}); // 让对象不可扩展（不能加新属性）

// 传统方式：失败抛错，需 try/catch
try {
  Object.defineProperty(obj, 'newProp', { value: 123 });
  console.log('定义成功');
} catch (e) {
  console.log('定义失败'); // 会执行这里（对象不可扩展）
}

// Reflect 方式：返回布尔值，直接判断
if (Reflect.defineProperty(obj, 'newProp', { value: 123 })) {
  console.log('定义成功');
} else {
  console.log('定义失败'); // 会执行这里（更简洁）
}

const parent = {
  _name: 'Parent',
  get name() {
    return this._name; // this 应该指向调用者
  },
};

// 用 Proxy 代理 parent
const parentProxy = new Proxy(parent, {
  get(target, propKey, receiver) {
    // 错误方式：target[propKey] 会让 this 指向 target（parent）
    // return target[propKey];

    // 正确方式：Reflect.get 传递 receiver（this 指向调用者）
    return Reflect.get(target, propKey, receiver);
  },
});

// 子对象继承代理
const child = {
  __proto__: parentProxy,
  _name: 'Child', // 子对象自己的 _name
};

console.log(child.name);
// 错误方式输出 "Parent"（this 指向 parent）
// 正确方式输出 "Child"（this 指向 child，符合继承逻辑）

const obj = {};

// 定义一组操作：批量设置属性
const operations = [
  () => Reflect.set(obj, 'a', 1),
  () => Reflect.set(obj, 'b', 2),
  () => Reflect.set(obj, 'c', 3),
];

// 执行所有操作，判断是否全部成功
const allSuccess = operations.every((op) => op());

if (allSuccess) {
  console.log('所有属性设置成功', obj); // { a:1, b:2, c:3 }
} else {
  console.log('部分操作失败');
}

function reactive(target) {
  return new Proxy(target, {
    get(target, propKey, receiver) {
      track(target, propKey); // 收集依赖（响应式核心）
      return Reflect.get(target, propKey, receiver); // 默认读操作
    },
    set(target, propKey, value, receiver) {
      const oldValue = Reflect.get(target, propKey, receiver);
      const success = Reflect.set(target, propKey, value, receiver);
      if (success && oldValue !== value) {
        trigger(target, propKey); // 触发更新（响应式核心）
      }
      return success;
    },
  });
}

// 安全设置对象属性的工具函数
function safeSet(obj, prop, value) {
  // 先判断对象是否可扩展，再设置属性
  if (Reflect.isExtensible(obj)) {
    return Reflect.set(obj, prop, value);
  }
  console.warn('对象不可扩展，无法设置属性');
  return false;
}

// 测试：不可扩展对象
const frozenObj = Object.freeze({}); // 冻结对象（不可扩展、不可修改）
safeSet(frozenObj, 'name', 'Alice'); // 输出警告，返回 false（不抛错）

// 多继承实现：让对象拥有多个原型的方法
function createMultiProto(...prototypes) {
  return new Proxy(
    {},
    {
      get(target, propKey, receiver) {
        // 按顺序在多个原型中查找属性
        for (const proto of prototypes) {
          if (Reflect.has(proto, propKey)) {
            return Reflect.get(proto, propKey, receiver);
          }
        }
        return undefined;
      },
    },
  );
}

// 定义三个“能力”对象
const canEat = { eat: () => console.log('吃饭') };
const canWalk = { walk: () => console.log('走路') };
const canSwim = { swim: () => console.log('游泳') };

// 创建多继承对象
const person = createMultiProto(canEat, canWalk, canSwim);
person.eat(); // 吃饭（来自 canEat）
person.walk(); // 走路（来自 canWalk）
person.swim(); // 游泳（来自 canSwim）