pragma solidity ^0.8.1;

import "@interfaces/IGovernance.sol";
import "@interfaces/IERC20.sol";

import "@proprietary/Parameters.sol";
import "@proprietary/Mock.sol";

import "@root/Proposal.sol";
import "@forge-std/Test.sol";

contract ProposalTest is Test, Parameters, Mock {
    modifier conditionStateChecks() {
        checkParameters();
        _;
        checkResults();
    }

    function testProposal() public conditionStateChecks {
        uint256 proposalId = voteAndCreateProposal(address(new Proposal()));

        IGovernance(_governanceAddress).execute(proposalId);
    }

    function voteAndCreateProposal(
        address proposalAddress
    ) public returns (uint256) {
        retrieveAndLockBalance(
            TEST_PRIVATE_KEY_ONE,
            TEST_ADDRESS_ONE,
            PROPOSAL_THRESHOLD
        );
        retrieveAndLockBalance(TEST_PRIVATE_KEY_TWO, TEST_ADDRESS_TWO, 1 ether);

        /* ----------PROPOSER------------ */
        vm.startPrank(TEST_ADDRESS_ONE);

        uint256 proposalId = IGovernance(_governanceAddress).propose(
            proposalAddress,
            PROPOSAL_DESCRIPTION
        );

        // TIME-TRAVEL
        vm.warp(block.timestamp + 6 hours);

        IGovernance(_governanceAddress).castVote(proposalId, true);

        vm.stopPrank();
        /* ------------------------------ */

        /* -------------VOTER-------------*/
        vm.startPrank(TEST_ADDRESS_TWO);
        IGovernance(_governanceAddress).castVote(proposalId, true);
        vm.stopPrank();
        /* ------------------------------ */

        // TIME-TRAVEL
        vm.warp(block.timestamp + PROPOSAL_DURATION);

        return proposalId;
    }

    function retrieveAndLockBalance(
        uint256 privateKey,
        address voter,
        uint256 amount
    ) internal {
        uint256 lockTimestamp = block.timestamp + PROPOSAL_DURATION;
        bytes32 messageHash = keccak256(
            abi.encodePacked(
                PERMIT_FUNC_SELECTOR,
                EIP712_DOMAIN,
                keccak256(
                    abi.encode(
                        PERMIT_TYPEHASH,
                        voter,
                        _governanceAddress,
                        amount,
                        0,
                        lockTimestamp
                    )
                )
            )
        );

        /* ----------GOVERNANCE------- */
        vm.startPrank(_governanceAddress);
        IERC20(_tokenAddress).transfer(voter, amount);
        vm.stopPrank();
        /* ----------------------------*/

        (uint8 v, bytes32 r, bytes32 s) = vm.sign(privateKey, messageHash);

        /* ----------VOTER------------ */
        vm.startPrank(voter);
        IGovernance(_governanceAddress).lock(
            voter,
            amount,
            lockTimestamp,
            v,
            r,
            s
        );
        vm.stopPrank();
        /* ----------------------------*/
    }

    function checkParameters() internal {
        require(REMUNERATION_NORMALISED_AMOUNT > 4100 ether);
    }

    function checkResults() internal {
        require(
            IERC20(_tokenAddress).balanceOf(REMUNERATION_ADDRESS) == 834 ether
        );
    }
}