// 代理合约
contract Proxy {
    address public implementation;
    
    fallback() external {
        (bool ok, ) = implementation.delegatecall(msg.data);
        // 状态变化写在 Proxy 的存储中！
    }
}

// 实现合约
contract LogicV1 {
    address public implementation; // 必须与代理存储布局一致！
    mapping(address => uint256) public balances;
    
    function deposit() external {
        balances[msg.sender] += msg.value; // 写 Proxy 的存储！
    }
}

/**
 * EVM 存储布局分析：变量定义的偏移必须一致
 * 否则升级后数据会错位
 */
interface StorageSlot {
  offset: number;   // 字节偏移（连续变量可共享 32 字节槽位）
  slot: number;     // 存储槽位索引（每个 32 字节）
  type: string;
  variable: string;
}

// V1 布局
const layoutV1: StorageSlot[] = [
  { offset: 0, slot: 0, type: "address", variable: "owner" },
  { offset: 0, slot: 1, type: "uint256", variable: "totalSupply" },
  { offset: 0, slot: 2, type: "mapping(address=>uint256)", variable: "balances" },
  // mapping 本身只占 1 槽位，数据在 keccak256(key, slot)
];

// V2 升级——错误！插入新变量到中间
const layoutV2_Wrong: StorageSlot[] = [
  { offset: 0, slot: 0, type: "address", variable: "owner" },
  { offset: 0, slot: 1, type: "bool", variable: "paused" },      // 插入！
  { offset: 1, slot: 1, type: "uint248", variable: "totalSupply" }, // 位移错位
  { offset: 0, slot: 2, type: "mapping", variable: "balances" },
];

// V2 正确——新变量只能追加到最末尾
const layoutV2_Correct: StorageSlot[] = [
  { offset: 0, slot: 0, type: "address", variable: "owner" },
  { offset: 0, slot: 1, type: "uint256", variable: "totalSupply" },
  { offset: 0, slot: 2, type: "mapping", variable: "balances" },
  // ---- 追加新变量到 slot 3 ----
  { offset: 0, slot: 3, type: "bool", variable: "paused" },
  { offset: 0, slot: 4, type: "uint256", variable: "newField" },
];

function checkUpgradeCompatibility(oldL: StorageSlot[], newL: StorageSlot[]): {
  compatible: boolean;
  issues: string[];
} {
  const issues: string[] = [];
  for (const oldVar of oldL) {
    const match = newL.find(nv =>
      nv.slot === oldVar.slot && nv.variable === oldVar.variable && nv.type === oldVar.type
    );
    if (!match) {
      issues.push(`变量 ${oldVar.variable} (slot${oldVar.slot}) 被修改或删除`);
    }
  }
  return { compatible: issues.length === 0, issues };
}

const check = checkUpgradeCompatibility(layoutV1, layoutV2_Wrong);
console.log("V2_Wrong 兼容性:", check.compatible, check.issues);
// 预期: false + “变量 totalSupply (slot 1) 被修改”

const check2 = checkUpgradeCompatibility(layoutV1, layoutV2_Correct);
console.log("V2_Correct 兼容性:", check2.compatible, check2.issues);
// 预期: true

// UUPS 代理（极简，无逻辑）
contract UUPSProxy {
    address public implementation;
    
    fallback() external {
        implementation.delegatecall(msg.data);
    }
}

// 实现合约包含升级函数
contract UUPSImplementation {
    address public implementation;  // 与代理同一槽位
    
    function upgradeTo(address newImpl) external {
        require(msg.sender == owner, "only owner");
        // 检查新实现是否是有效合约
        implementation = newImpl;
    }
    
    function _authorizeUpgrade(address) internal view virtual; // 子类覆盖权限
}

mapping(bytes4 => address) selectorToFacet;

function _delegate(bytes4 selector) internal {
    address facet = selectorToFacet[selector];
    assembly { delegatecall(gas(), facet, 0, 0, 0, 0) }
}

// 优势：可以同时升级单个函数，无需替换整个实现
// 代价：复杂度极高，Gas 略增

contract TokenV1 {
    bool private _initialized;  // 防止 double init
    
    function initialize(address owner, string calldata name) public {
        require(!_initialized, "already initialized");
        _initialized = true;
        owner = owner; // 在代理上下文中写存储！
        name_ = name;
    }
}