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

// Research harness only; this is not a production procurement contract.
interface ICoreReader {
    function spotBalance(address user, uint64 token) external view returns (uint64 total, uint64 hold, uint64 entryNtl);
    function coreUserExists(address user) external view returns (bool);
    function coreBlockNumber() external view returns (uint64);
}
interface ICoreWriter { function sendRawAction(bytes calldata data) external; }
interface IERC20Balance { function balanceOf(address user) external view returns (uint256); }

contract OfficialCoreReader is ICoreReader {
    function spotBalance(address user, uint64 token) external view returns (uint64 total, uint64 hold, uint64 entryNtl) {
        (bool ok, bytes memory data) = address(0x801).staticcall(abi.encode(user, token));
        require(ok && data.length == 96, "CORE_BALANCE_READ_FAILED");
        return abi.decode(data, (uint64,uint64,uint64));
    }
    function coreUserExists(address user) external view returns (bool) {
        (bool ok, bytes memory data) = address(0x810).staticcall(abi.encode(user));
        require(ok && data.length == 32, "CORE_ACCOUNT_READ_FAILED");
        return abi.decode(data, (bool));
    }
    function coreBlockNumber() external view returns (uint64) {
        (bool ok, bytes memory data) = address(0x809).staticcall("");
        require(ok && data.length == 32, "CORE_BLOCK_READ_FAILED");
        return abi.decode(data, (uint64));
    }
}

// Explicit substitute for the Core state that ordinary Anvil does not execute.
// The model is visibly injected as the immutable reader; it is never installed
// at a precompile address or presented as actual HyperCore settlement.
contract LocalCoreReadModel is ICoreReader {
    address public immutable harness;
    struct Balance { uint64 total; uint64 hold; uint64 entryNtl; }
    mapping(address => mapping(uint64 => Balance)) public balances;
    mapping(address => bool) public exists;
    uint64 public currentCoreBlock = 100;
    constructor() { harness = msg.sender; }
    modifier onlyHarness() { require(msg.sender == harness, "MODEL_HARNESS_ONLY"); _; }
    function setAccount(address user, bool active) external onlyHarness { exists[user] = active; }
    function setBalance(address user, uint64 token, uint64 total, uint64 hold) external onlyHarness {
        require(hold <= total, "MODEL_INVALID_HOLD");
        balances[user][token] = Balance(total, hold, 0);
    }
    function nextCoreBlock() external onlyHarness { currentCoreBlock++; }
    function spotBalance(address user, uint64 token) external view returns (uint64, uint64, uint64) {
        Balance memory b = balances[user][token]; return (b.total,b.hold,b.entryNtl);
    }
    function coreUserExists(address user) external view returns (bool) { return exists[user]; }
    function coreBlockNumber() external view returns (uint64) { return currentCoreBlock; }
}

contract CoreOwnedNvdaExecutor {
    address public constant CORE_WRITER = 0x3333333333333333333333333333333333333333;
    address public constant NVDA_SYSTEM = 0x200000000000000000000000000000000000034d;
    address public constant NVDA_EVM = 0xa8ddb5Cd96b5222AFe198316E9A57CAA642850D5;
    uint64 public constant NVDA_TOKEN = 845;
    uint64 public constant USDC_TOKEN = 0;
    uint64 public constant HYPE_TOKEN = 150;
    uint32 public constant NVDA_ORDER_ASSET = 10702;
    uint32 public constant SPOT_DEX = type(uint32).max;
    uint256 public constant CORE_TO_EVM_SCALE = 1e10; // NVDAX8 -> ERC20 18.
    uint64 public constant MIN_CORE_HYPE_GAS = 1_000_000; // 0.01 HYPE reserve in this harness.

    ICoreReader public immutable reader;
    uint64 public immutable limitPrice8;
    uint64 public immutable orderSize8;
    uint64 public immutable maxBudgetUsdc8;
    uint64 public immutable minNetStock8;
    uint128 public immutable orderCloid;
    enum Stage { Ready, BuyQueued, FillObserved, WithdrawalQueued, Complete }
    Stage public stage;
    uint64 public stockBaseline8;
    uint64 public quoteBaseline8;
    uint64 public submittedCoreBlock;
    uint64 public actualNetStock8;
    uint64 public actualSpentUsdc8;
    uint256 public evmStockBaseline;
    event BuyQueued(uint128 indexed cloid, uint64 size8, uint64 limitPrice8);
    event FillObserved(uint64 netStock8, uint64 spentUsdc8);
    event WithdrawalQueued(uint64 netStock8);
    event WithdrawalConfirmed(uint256 evmAmount);

    constructor(ICoreReader reader_, uint64 price8, uint64 size8, uint64 budget8, uint64 minNet8, uint128 cloid) {
        require(address(reader_) != address(0), "BAD_READER");
        require(price8 > 0 && size8 > 0 && minNet8 > 0 && minNet8 <= size8 && cloid != 0, "BAD_ORDER");
        // ceil(size * limit price) protects the maximum quote-token spend.
        require((uint256(price8) * size8 + 1e8 - 1) / 1e8 <= budget8, "WORST_PRICE_EXCEEDS_BUDGET");
        reader = reader_; limitPrice8 = price8; orderSize8 = size8;
        maxBudgetUsdc8 = budget8; minNetStock8 = minNet8; orderCloid = cloid;
    }
    receive() external payable {}
    function freeBalance(uint64 token) public view returns (uint64) {
        (uint64 total,uint64 hold,) = reader.spotBalance(address(this), token);
        require(total >= hold, "INVALID_CORE_BALANCE"); return total - hold;
    }
    // Permissionless trigger; no caller-selected asset/recipient/calldata.
    function submitBuy() external {
        require(stage == Stage.Ready, "ORDER_ALREADY_SUBMITTED");
        require(reader.coreUserExists(address(this)), "CORE_ACCOUNT_INACTIVE");
        require(freeBalance(HYPE_TOKEN) >= MIN_CORE_HYPE_GAS, "KEEP_CORE_HYPE_FOR_EXIT");
        uint64 worstCost8 = uint64((uint256(limitPrice8) * orderSize8 + 1e8 - 1) / 1e8);
        require(freeBalance(USDC_TOKEN) >= worstCost8, "CORE_USDC_INSUFFICIENT");
        (stockBaseline8,,) = reader.spotBalance(address(this), NVDA_TOKEN);
        (quoteBaseline8,,) = reader.spotBalance(address(this), USDC_TOKEN);
        submittedCoreBlock = reader.coreBlockNumber();
        stage = Stage.BuyQueued;
        bytes memory action = abi.encodePacked(bytes4(0x01000001), abi.encode(
            NVDA_ORDER_ASSET, true, limitPrice8, orderSize8, false, uint8(3), orderCloid
        ));
        ICoreWriter(CORE_WRITER).sendRawAction(action);
        emit BuyQueued(orderCloid, orderSize8, limitPrice8);
    }
    // Balance observation is a conservative completion predicate for this
    // single-job harness, not a replacement for a production order-status ledger.
    // A zero or below-minimum partial fill stays pending and is never re-ordered.
    function observeFill() external {
        require(stage == Stage.BuyQueued, "NO_PENDING_BUY");
        require(reader.coreBlockNumber() > submittedCoreBlock, "WAIT_FOR_LATER_CORE_BLOCK");
        (uint64 stock,uint64 stockHold,) = reader.spotBalance(address(this), NVDA_TOKEN);
        (uint64 quote,uint64 quoteHold,) = reader.spotBalance(address(this), USDC_TOKEN);
        require(stockHold == 0 && quoteHold == 0, "CORE_FUNDS_STILL_HELD");
        require(stock >= stockBaseline8 && quote <= quoteBaseline8, "UNEXPECTED_CORE_BALANCE_CHANGE");
        uint64 net = stock - stockBaseline8;
        uint64 spent = quoteBaseline8 - quote;
        require(net >= minNetStock8 && net <= orderSize8, "FILL_BELOW_MINIMUM_OR_INVALID");
        require(spent > 0 && spent <= maxBudgetUsdc8, "INVALID_OBSERVED_SPEND");
        actualNetStock8 = net; actualSpentUsdc8 = spent; stage = Stage.FillObserved;
        emit FillObserved(net,spent);
    }
    function submitWithdrawal() external {
        require(stage == Stage.FillObserved, "FILL_NOT_CONFIRMED_OR_EXIT_ALREADY_SENT");
        require(freeBalance(NVDA_TOKEN) >= actualNetStock8, "CORE_STOCK_NOT_FREE");
        require(freeBalance(HYPE_TOKEN) >= MIN_CORE_HYPE_GAS, "KEEP_CORE_HYPE_FOR_EXIT");
        evmStockBaseline = IERC20Balance(NVDA_EVM).balanceOf(address(this));
        stage = Stage.WithdrawalQueued;
        bytes memory action = abi.encodePacked(bytes4(0x0100000d), abi.encode(
            NVDA_SYSTEM, address(0), SPOT_DEX, SPOT_DEX, NVDA_TOKEN, actualNetStock8
        ));
        ICoreWriter(CORE_WRITER).sendRawAction(action);
        emit WithdrawalQueued(actualNetStock8);
    }
    function confirmWithdrawal() external {
        require(stage == Stage.WithdrawalQueued, "NO_PENDING_EXIT");
        uint256 received = IERC20Balance(NVDA_EVM).balanceOf(address(this)) - evmStockBaseline;
        require(received == uint256(actualNetStock8) * CORE_TO_EVM_SCALE, "EVM_STOCK_NOT_RECEIVED_EXACTLY");
        (uint64 coreStock,,) = reader.spotBalance(address(this), NVDA_TOKEN);
        require(coreStock == stockBaseline8, "CORE_EXIT_NOT_OBSERVED");
        stage = Stage.Complete; emit WithdrawalConfirmed(received);
    }
}