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

import {Test} from "forge-std/Test.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {OuroborosPress} from "src/OuroborosPress.sol";
import {IIntakeV2} from "src/interfaces/IIntakeV2.sol";

/// @dev 18-decimal stand-in for IMD at the real Robinhood address.
contract ScratchIMD is ERC20 {
    constructor() ERC20("Identity MD", "IMD") {}

    function mint(address to, uint256 amount) external {
        _mint(to, amount);
    }
}

/// @dev Intake v2 as the docs describe it, with the owner-settable price the real one has:
///      `priceOf(action, asset)` is the live price; `requestWithFailure` reverts below it and
///      pulls exactly `amount` (never refunds the excess) to the treasury in the same call.
contract ScratchIntake is IIntakeV2 {
    error PriceNotMet();

    address public constant TREASURY = address(0x7EA5);
    mapping(bytes32 => mapping(address => uint256)) public priceOf;
    uint256 public nonce;

    function setPrice(bytes32 action, address asset, uint256 price) external {
        priceOf[action][asset] = price;
    }

    function request(bytes32, bytes calldata, Callback calldata, address, uint256) external pure returns (bytes32) {
        revert("unused");
    }

    function requestWithFailure(bytes32 action, bytes calldata, Callback calldata, bytes4, address asset, uint256 amount)
        external
        returns (bytes32 id)
    {
        uint256 price = priceOf[action][asset];
        if (price == 0 || amount < price) revert PriceNotMet();
        require(IERC20(asset).transferFrom(msg.sender, TREASURY, amount), "pull failed");
        id = keccak256(abi.encode(block.chainid, address(this), ++nonce, msg.sender));
    }
}

/// @notice The press hardcodes PRICE = 0.5 IMD instead of reading `priceOf` on each ask. If the
///         Intake's price moves (it is owner-settable, and the docs say "a moved price must not
///         need a redeploy"), the press either reverts forever (price up: every IMD it holds is
///         frozen, there is no admin or withdraw) or overpays (price down: the difference is lost
///         on every chapter). Fails on the code as it is; passes once `commission()` pays the
///         live `priceOf(ACTION_JOB_OPEN, imd)` instead of the constant.
contract PriceFollowsIntakeScratch is Test {
    address constant INTAKE = 0xa43e6F75ee006411F79Ac1C84120606C2330DE82;
    address constant IMD = 0x5F7Bb59365ce557C26dbcAa4EE9d39A4b95B7127;
    bytes32 constant JOB_OPEN = "job.open@job-1";

    ScratchIMD imd;
    ScratchIntake intake;
    OuroborosPress press;

    function setUp() public {
        vm.warp(1_792_000_000);
        vm.etch(IMD, address(new ScratchIMD()).code);
        vm.etch(INTAKE, address(new ScratchIntake()).code);
        imd = ScratchIMD(IMD);
        intake = ScratchIntake(INTAKE);
        press = new OuroborosPress();
    }

    /// Price raised from 0.5 to 0.6 IMD: the press holds 5 IMD and nothing can ever spend it.
    function test_priceRaisedAboveConstantFreezesEveryIMDInThePress() public {
        intake.setPrice(JOB_OPEN, IMD, 0.6e18);
        imd.mint(address(press), 5e18);

        // Expected: the press pays the live price (0.6 IMD) and the chapter is ordered.
        // Actual on the current code: ScratchIntake.PriceNotMet() on every attempt, forever.
        bytes32 id = press.commission();
        assertTrue(id != bytes32(0));
        assertEq(imd.balanceOf(intake.TREASURY()), 0.6e18, "pays the live price");
        assertEq(imd.balanceOf(address(press)), 5e18 - 0.6e18);
    }

    /// Price lowered from 0.5 to 0.25 IMD: the press still sends 0.5 and the Intake keeps it all.
    function test_priceLoweredBelowConstantOverpaysEveryChapter() public {
        intake.setPrice(JOB_OPEN, IMD, 0.25e18);
        imd.mint(address(press), 1e18);

        press.commission();
        // Expected: exactly the live price (0.25 IMD) leaves the press.
        // Actual on the current code: 0.5 IMD leaves; 0.25 IMD per chapter is lost to the treasury.
        assertEq(imd.balanceOf(intake.TREASURY()), 0.25e18, "pays only the live price");
        assertEq(imd.balanceOf(address(press)), 1e18 - 0.25e18);
    }
}