// [Insert your actual Solidity contract code here]
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

// Example Placeholder Contract - Replace with your actual code
contract WeaveHashrateInvestment {
    address public owner;
    uint256 public pricePerThs = 100 * 10**6; // Example: $100 USDT (6 decimals) per TH/s
    IERC20 public paymentToken; // e.g., USDT address
    uint256 public minimumInvestmentThs = 10; // Example: 1 TH/s (scaled by 1 decimal place)

    struct User {
        uint256 totalHashrateThs; // Total TH/s owned (scaled by 1 decimal place)
        uint256 lastClaimTimestamp;
        // ... other user data ...
    }

    mapping(address => User) public users;
    uint256 public totalPlatformHashrateThs;

    event Invested(address indexed user, uint256 hashrateAmountThs, uint256 cost);
    event YieldClaimed(address indexed user, uint256 amount);

    constructor(address _paymentTokenAddress) {
        owner = msg.sender;
        paymentToken = IERC20(_paymentTokenAddress);
    }

    function invest(uint256 _hashrateAmountThs) public { // Input scaled hashrate (e.g., 10 for 1.0 TH/s)
        require(_hashrateAmountThs >= minimumInvestmentThs, "Investment below minimum");
        uint256 cost = (_hashrateAmountThs * pricePerThs) / 10; // Calculate cost based on scaled input

        // TODO: Check allowance and transfer payment token
        // require(paymentToken.transferFrom(msg.sender, address(this), cost), "Token transfer failed");

        users[msg.sender].totalHashrateThs += _hashrateAmountThs;
        totalPlatformHashrateThs += _hashrateAmountThs;

        emit Invested(msg.sender, _hashrateAmountThs, cost);
    }

    function calculateYield(address _user) public view returns (uint256) {
        // TODO: Implement complex yield calculation based on user's hashrate, time since last claim,
        // target APR, BTC price, network difficulty, pool performance etc.
        // This is highly simplified:
        uint256 userHashrate = users[_user].totalHashrateThs;
        uint256 timeElapsed = block.timestamp - users[_user].lastClaimTimestamp;
        // Placeholder: ~20% APR on the *cost basis* (pricePerThs) per second
        uint256 costBasis = (userHashrate * pricePerThs) / 10;
        uint256 yearlyYield = (costBasis * 20) / 100; // Simplified 20% APR
        uint256 yieldPerSecond = yearlyYield / (365 days);
        return yieldPerSecond * timeElapsed;
    }


    function claimYield() public {
        uint256 yieldAmount = calculateYield(msg.sender);
        require(yieldAmount > 0, "No yield to claim");

        users[msg.sender].lastClaimTimestamp = block.timestamp;

        // TODO: Transfer calculated yield amount (in yield currency, might be same as payment token)
        // require(paymentToken.transfer(msg.sender, yieldAmount), "Yield transfer failed");

        emit YieldClaimed(msg.sender, yieldAmount);
    }

    // ... other functions (referrals, admin controls etc.) placeholder ...
}

interface IERC20 {
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    // ... other relevant IERC20 functions ...
}