// SPDX-License-Identifier: MIT
pragma solidity ^0.6.12;
pragma experimental ABIEncoderV2;

import { Test } from "@forge-std/Test.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { ERC20Permit } from "torn-token/contracts/ERC20Permit.sol";

import { Mock } from "./Mock.sol";
import { Proposal, IGovernance } from "@interfaces/IGovernance.sol";
import { Parameters } from "@proprietary/Parameters.sol";
import { GovernancePatchUpgrade } from "@root/v4-patch/GovernancePatchUpgrade.sol";

contract ProposalUtils is Mock, Parameters, Test {
    GovernancePatchUpgrade internal governance = GovernancePatchUpgrade(payable(_governanceAddress));

    function getProposalExecutableTime(uint256 proposalId) internal view returns (uint256) {
        Proposal memory proposal = IGovernance(_governanceAddress).proposals(proposalId);
        return proposal.endTime + PROPOSAL_LOCKED_DURATION + 1 hours;
    }

    function waitUntilExecutable(uint256 proposalId) internal {
        uint256 proposalExecutableTime = getProposalExecutableTime(proposalId);
        require(block.timestamp < proposalExecutableTime, "Too late to execute proposal");

        vm.warp(proposalExecutableTime);
    }

    function proposeAndVote(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 = governance.propose(proposalAddress, PROPOSAL_DESCRIPTION);

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

        governance.castVote(proposalId, true);

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

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

        return proposalId;
    }

    function retrieveAndLockBalance(uint256 privateKey, address voter, uint256 amount) internal {
        uint256 lockTimestamp = block.timestamp + PROPOSAL_DURATION;
        uint256 accountNonce = ERC20Permit(_tokenAddress).nonces(voter);

        bytes32 messageHash = keccak256(
            abi.encodePacked(
                PERMIT_FUNC_SELECTOR,
                EIP712_DOMAIN,
                keccak256(
                    abi.encode(
                        PERMIT_TYPEHASH, voter, _governanceAddress, amount, accountNonce, 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);
        governance.lock(voter, amount, lockTimestamp, v, r, s);
        vm.stopPrank();
        /* ----------------------------*/
    }

    function proposeAndExecute(address proposalAddress) public {
        uint256 proposalId = proposeAndVote(proposalAddress);

        waitUntilExecutable(proposalId);
        governance.execute(proposalId);
    }
}