import { expect } from "chai";
import hre, { deployments, waffle } from "hardhat";
import "@nomiclabs/hardhat-ethers";
import { getSafeWithOwners } from "../utils/setup";
import { executeContractCallWithSigners, calculateSafeMessageHash } from "../../src/utils/execution";
import { chainId } from "../utils/encoding";

describe("SignMessageLib", async () => {

    const [user1, user2] = waffle.provider.getWallets()

    const setupTests = deployments.createFixture(async ({ deployments }) => {
        await deployments.fixture();
        const lib = await (await hre.ethers.getContractFactory("SignMessageLib")).deploy();
        return {
            safe: await getSafeWithOwners([user1.address, user2.address]),
            lib
        }
    })

    describe("signMessage", async () => {

        it('can only if msg.sender provides domain separator', async () => {
            const { lib } = await setupTests()
            await expect(lib.signMessage("0xbaddad")).to.be.reverted
        })

        it('should emit event', async () => {
            const { safe, lib } = await setupTests()
            // Required to check that the event was emitted from the right address
            const libSafe = lib.attach(safe.address)
            const messageHash = calculateSafeMessageHash(safe, "0xbaddad", await chainId())
            
            expect(
                await safe.signedMessages(messageHash)
            ).to.be.eq(0)

            await expect(
                executeContractCallWithSigners(safe, lib, "signMessage", ["0xbaddad"], [user1, user2], true)
            ).to.emit(libSafe, "SignMsg").withArgs(messageHash)

            expect(
                await safe.signedMessages(messageHash)
            ).to.be.eq(1)
        })

        it('can be used only via DELEGATECALL opcode', async () => {
            const { lib } = await setupTests()

            expect(lib.signMessage("0xbaddad")).to.revertedWith("function selector was not recognized and there's no fallback function");
        })

        it("changes the expected storage slot without touching the most important ones", async () => {
          const { safe, lib } = await setupTests();

          const SIGNED_MESSAGES_MAPPING_STORAGE_SLOT = 7
          const message = "no rugpull, funds must be safu";
          const eip191MessageHash = hre.ethers.utils.hashMessage(message);
          const safeInternalMsgHash = calculateSafeMessageHash(
            safe,
            hre.ethers.utils.hashMessage(message),
            await chainId()
          );
          const expectedStorageSlot = hre.ethers.utils.keccak256(
            hre.ethers.utils.defaultAbiCoder.encode(["bytes32", "uint256"], [safeInternalMsgHash, SIGNED_MESSAGES_MAPPING_STORAGE_SLOT])
          );

          const masterCopyAddressBeforeSigning = await hre.ethers.provider.getStorageAt(safe.address, 0);
          const ownerCountBeforeSigning = await hre.ethers.provider.getStorageAt(safe.address, 3);
          const thresholdBeforeSigning = await hre.ethers.provider.getStorageAt(safe.address, 4);
          const nonceBeforeSigning = await hre.ethers.provider.getStorageAt(safe.address, 5);
          const msgStorageSlotBeforeSigning = await hre.ethers.provider.getStorageAt(safe.address, expectedStorageSlot);
          
          expect(nonceBeforeSigning).to.be.eq(`0x${"0".padStart(64, "0")}`);
          expect(await safe.signedMessages(safeInternalMsgHash)).to.be.eq(0);
          expect(msgStorageSlotBeforeSigning).to.be.eq(`0x${"0".padStart(64, "0")}`);
          
          await executeContractCallWithSigners(safe, lib, "signMessage", [eip191MessageHash], [user1, user2], true);
          
          const masterCopyAddressAfterSigning = await hre.ethers.provider.getStorageAt(safe.address, 0);
          const ownerCountAfterSigning = await hre.ethers.provider.getStorageAt(safe.address, 3);
          const thresholdAfterSigning = await hre.ethers.provider.getStorageAt(safe.address, 4);
          const nonceAfterSigning = await hre.ethers.provider.getStorageAt(safe.address, 5);
          const msgStorageSlotAfterSigning = await hre.ethers.provider.getStorageAt(safe.address, expectedStorageSlot);
          
          expect(await safe.signedMessages(safeInternalMsgHash)).to.be.eq(1);
          expect(masterCopyAddressBeforeSigning).to.be.eq(masterCopyAddressAfterSigning);
          expect(thresholdBeforeSigning).to.be.eq(thresholdAfterSigning);
          expect(ownerCountBeforeSigning).to.be.eq(ownerCountAfterSigning);
          expect(nonceAfterSigning).to.be.eq(`0x${"1".padStart(64, "0")}`);
          expect(msgStorageSlotAfterSigning).to.be.eq(`0x${"1".padStart(64, "0")}`);
        });
    })
})