// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/**
 * @title 代际财富管理系统 - 完整版
 * @notice 实现22年首代注册、生育控制、赡养义务与跨代继承
 */
contract GenerationalWealth {
    // ======================
    // 1. 常量定义
    // ======================
    uint256 private constant SECONDS_PER_YEAR = 31536000;
    uint256 public constant GENESIS_PERIOD = 22 * SECONDS_PER_YEAR;
    uint256 public constant FERTILITY_WINDOW = 20 * SECONDS_PER_YEAR;
    uint256 public constant LIFESPAN = 100 * SECONDS_PER_YEAR;
    uint256 public constant SUPPORT_INTERVAL = 30 days;
    uint256 public constant SUPPORT_RATE = 5; // 5%
    uint256 public constant MAX_CHILDREN = 3;

    // ======================
    // 2. 数据结构
    // ======================
    struct Person {
        uint256 birthTime;
        address[2] parents;
        address[] children;
        address spouse;
        uint256 fertilityEnd;
        uint256 lastSupportPaid;
    }

    // ======================
    // 3. 存储变量
    // ======================
    mapping(address => Person) public people;
    address[] public population;
    uint256 public immutable genesisEndTime;

    // ======================
    // 4. 事件定义
    // ======================
    event Registered(address indexed who);
    event Married(address indexed partner1, address indexed partner2);
    event ChildBorn(address indexed parent1, address indexed parent2, address child);
    event SupportPaid(address indexed from, address indexed to, uint256 amount);
    event Inherited(address indexed from, address[] heirs, uint256[] amounts);

    // ======================
    // 5. 构造函数
    // ======================
    constructor() {
        genesisEndTime = block.timestamp + GENESIS_PERIOD;
    }

    // ======================
    // 6. 外部函数
    // ======================

    /**
     * @dev 首代注册（前22年有效）
     */
    function register() external {
        require(block.timestamp < genesisEndTime, "GENESIS_PERIOD_ENDED");
        require(people[msg.sender].birthTime == 0, "ALREADY_REGISTERED");

        people[msg.sender] = Person({
            birthTime: block.timestamp,
            parents: [address(0), address(0)],
            children: new address[](0),
            spouse: address(0),
            fertilityEnd: block.timestamp + FERTILITY_WINDOW,
            lastSupportPaid: 0
        });
        population.push(msg.sender);
        
        emit Registered(msg.sender);
    }

    /**
     * @dev 创建家庭并生育子代
     * @param partner 配偶地址
     */
    function createFamily(address partner) external returns (address child) {
        require(block.timestamp >= genesisEndTime, "GENESIS_PERIOD_ACTIVE");
        require(msg.sender != partner, "SELF_MARRIAGE");
        require(people[msg.sender].spouse == address(0), "ALREADY_MARRIED");
        require(people[partner].spouse == address(0), "PARTNER_MARRIED");
        require(people[msg.sender].children.length < MAX_CHILDREN, "CHILD_LIMIT");
        require(block.timestamp < people[msg.sender].fertilityEnd, "FERTILITY_ENDED");

        // 使用CREATE2生成确定性子地址
        bytes memory creationCode = abi.encodePacked(
            type(ChildProxy).creationCode, 
            abi.encode(msg.sender, partner, address(this))
        );
        bytes32 salt = keccak256(abi.encodePacked(
            msg.sender, 
            partner, 
            people[msg.sender].children.length
        ));
        assembly {
            child := create2(0, add(creationCode, 0x20), mload(creationCode), salt)
        }

        // 注册子代
        _registerChild(msg.sender, partner, child);

        emit Married(msg.sender, partner);
        emit ChildBorn(msg.sender, partner, child);
    }

    /**
     * @dev 执行赡养费支付（需定期调用）
     */
    function executeSupport() external {
        for (uint256 i = 0; i < population.length; i++) {
            address person = population[i];
            if (_shouldPaySupport(person)) {
                _paySupport(person);
            }
        }
    }

    /**
     * @dev 执行遗产分配（需定期调用）
     */
    function executeInheritance() external {
        for (uint256 i = 0; i < population.length; i++) {
            address person = population[i];
            if (_shouldInherit(person)) {
                _distributeInheritance(person);
            }
        }
    }

    // ======================
    // 7. 公开查询函数
    // ======================

    /**
     * @dev 获取地址年龄
     */
    function getAge(address who) public view returns (uint256) {
        return (block.timestamp - people[who].birthTime) / SECONDS_PER_YEAR;
    }

    // ======================
    // 8. 内部函数
    // ======================

    /**
     * @dev 注册子代（供ChildProxy调用）
     */
    function _registerChild(address parent1, address parent2, address child) internal {
        people[parent1].spouse = parent2;
        people[parent2].spouse = parent1;
        people[parent1].children.push(child);
        people[parent2].children.push(child);
        
        people[child] = Person({
            birthTime: block.timestamp,
            parents: [parent1, parent2],
            children: new address[](0),
            spouse: address(0),
            fertilityEnd: block.timestamp + FERTILITY_WINDOW,
            lastSupportPaid: 0
        });
        population.push(child);
    }

    function _shouldPaySupport(address who) internal view returns (bool) {
        Person storage p = people[who];
        return getAge(who) >= 40 &&
               (p.parents[0] != address(0) || p.parents[1] != address(0)) &&
               block.timestamp >= p.lastSupportPaid + SUPPORT_INTERVAL &&
               address(who).balance > 0;
    }

    function _paySupport(address payer) internal {
        Person storage p = people[payer];
        uint256 paymentAmount = address(payer).balance * SUPPORT_RATE / 100;
        
        for (uint256 i = 0; i < 2; i++) {
            if (p.parents[i] != address(0)) {
                (bool sent, ) = p.parents[i].call{value: paymentAmount / 2}("");
                require(sent, "PAYMENT_FAILED");
                p.lastSupportPaid = block.timestamp;
                emit SupportPaid(payer, p.parents[i], paymentAmount / 2);
            }
        }
    }

    function _shouldInherit(address who) internal view returns (bool) {
        return getAge(who) >= 100 && 
               people[who].children.length > 0 &&
               address(who).balance > 0;
    }

    function _distributeInheritance(address deceased) internal {
        Person storage p = people[deceased];
        uint256 totalEstate = address(deceased).balance;
        
        // 计算分配比例
        uint256 childrenShare = totalEstate * 80 / 100;
        uint256 grandchildrenShare = totalEstate - childrenShare;
        
        // 准备受益人数组
        address[] memory heirs = new address[](p.children.length + _countGrandchildren(deceased));
        uint256[] memory amounts = new uint256[](heirs.length);
        uint256 heirIndex = 0;

        // 分配给子女（80%平分）
        uint256 perChild = childrenShare / p.children.length;
        for (uint256 i = 0; i < p.children.length; i++) {
            heirs[heirIndex] = p.children[i];
            amounts[heirIndex] = perChild;
            heirIndex++;
            (bool sent, ) = p.children[i].call{value: perChild}("");
            require(sent, "TRANSFER_FAILED");
        }

        // 分配给孙辈（20%平分）
        if (grandchildrenShare > 0) {
            uint256 totalGrandchildren = _countGrandchildren(deceased);
            if (totalGrandchildren > 0) {
                uint256 perGrandchild = grandchildrenShare / totalGrandchildren;
                for (uint256 i = 0; i < p.children.length; i++) {
                    address child = p.children[i];
                    for (uint256 j = 0; j < people[child].children.length; j++) {
                        heirs[heirIndex] = people[child].children[j];
                        amounts[heirIndex] = perGrandchild;
                        heirIndex++;
                        (bool sent, ) = people[child].children[j].call{value: perGrandchild}("");
                        require(sent, "TRANSFER_FAILED");
                    }
                }
            }
        }

        emit Inherited(deceased, heirs, amounts);
    }

    function _countGrandchildren(address grandparent) internal view returns (uint256) {
        uint256 count;
        Person storage gp = people[grandparent];
        for (uint256 i = 0; i < gp.children.length; i++) {
            count += people[gp.children[i]].children.length;
        }
        return count;
    }

    // ======================
    // 9. 回退函数
    // ======================
    receive() external payable {}
}

/**
 * @title 子地址代理合约
 * @dev 通过汇编代码实现确定性子地址生成
 */
contract ChildProxy {
    constructor(address parent1, address parent2, address wealthContract) {
        // 安全调用主合约
        (bool success, ) = wealthContract.call(
            abi.encodeWithSignature(
                "_registerChild(address,address,address)",
                parent1,
                parent2,
                address(this)
            )
        );
        require(success, "REGISTRATION_FAILED");
    }
}