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

contract RecordContractPlatform {
    struct Child {
        address childEOA;
        string role;
        uint256 createdAt;
    }
    
    // 主控EOA -> 子EOA数组的映射
    mapping(address => Child[]) public children;
    
    // 事件定义
    event ChildAdded(address indexed owner, address indexed childEOA, string role);
    event ChildRemoved(address indexed owner, address indexed childEOA);
    
    // 添加子EOA记录
    function addChild(address childEOA, string memory role) external {
        require(childEOA != address(0), "Invalid child address");
        require(bytes(role).length > 0, "Role cannot be empty");
        
        children[msg.sender].push(Child({
            childEOA: childEOA,
            role: role,
            createdAt: block.timestamp
        }));
        
        emit ChildAdded(msg.sender, childEOA, role);
    }
    
    // 查询子EOA列表
    function getChildren(address owner) external view returns (Child[] memory) {
        return children[owner];
    }
    
    // 获取子EOA数量
    function getChildrenCount(address owner) external view returns (uint256) {
        return children[owner].length;
    }
    
    // 移除子EOA记录（可选功能）
    function removeChild(address childEOA) external {
        Child[] storage ownerChildren = children[msg.sender];
        
        for (uint256 i = 0; i < ownerChildren.length; i++) {
            if (ownerChildren[i].childEOA == childEOA) {
                // 将最后一个元素移到当前位置，然后删除最后一个
                ownerChildren[i] = ownerChildren[ownerChildren.length - 1];
                ownerChildren.pop();
                
                emit ChildRemoved(msg.sender, childEOA);
                break;
            }
        }
    }
}

contract BatchTxLogic {
    address public immutable owner;
    
    constructor(address _owner) {
        owner = _owner;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call");
        _;
    }
    
    function batchTransfer(
        address[] calldata recipients, 
        uint256[] calldata amounts
    ) external payable onlyOwner {
        require(recipients.length == amounts.length, "Arrays length mismatch");
        
        for (uint256 i = 0; i < recipients.length; i++) {
            payable(recipients[i]).transfer(amounts[i]);
        }
    }
}

contract RecoveryLogic {
    address public immutable owner;
    mapping(address => uint256) public recoveryRequests;
    uint256 public constant RECOVERY_DELAY = 7 days;
    
    constructor(address _owner) {
        owner = _owner;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call");
        _;
    }
    
    function initiateRecovery(address newOwner) external onlyOwner {
        recoveryRequests[newOwner] = block.timestamp + RECOVERY_DELAY;
    }
    
    function executeRecovery(address newOwner) external {
        require(
            recoveryRequests[newOwner] > 0 && 
            block.timestamp >= recoveryRequests[newOwner], 
            "Recovery not ready"
        );
        
        // 转移所有资产到新地址
        payable(newOwner).transfer(address(this).balance);
    }
}

contract SubscriptionLogic {
    address public immutable owner;
    
    struct Subscription {
        address service;
        uint256 amount;
        uint256 interval;
        uint256 nextPayment;
        bool active;
    }
    
    mapping(uint256 => Subscription) public subscriptions;
    uint256 public subscriptionCount;
    
    constructor(address _owner) {
        owner = _owner;
    }
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call");
        _;
    }
    
    function createSubscription(
        address service, 
        uint256 amount, 
        uint256 interval
    ) external onlyOwner {
        subscriptions[subscriptionCount] = Subscription({
            service: service,
            amount: amount,
            interval: interval,
            nextPayment: block.timestamp + interval,
            active: true
        });
        subscriptionCount++;
    }
    
    function executePayment(uint256 subscriptionId) external {
        Subscription storage sub = subscriptions[subscriptionId];
        require(sub.active, "Subscription not active");
        require(block.timestamp >= sub.nextPayment, "Payment not due");
        
        payable(sub.service).transfer(sub.amount);
        sub.nextPayment = block.timestamp + sub.interval;
    }
}