import std/json
import pkg/asynctest
import pkg/questionable
import pkg/stint
import pkg/ethers
import ./hardhat
import ./miner
import ./mocks

type

  Erc20* = ref object of Contract
  TestToken = ref object of Erc20

  Transfer = object of Event
    sender {.indexed.}: Address
    receiver {.indexed.}: Address
    value: UInt256

method name*(erc20: Erc20): string {.base, contract, view.}
method totalSupply*(erc20: Erc20): UInt256 {.base, contract, view.}
method balanceOf*(erc20: Erc20, account: Address): UInt256 {.base, contract, view.}
method allowance*(erc20: Erc20, owner, spender: Address): UInt256 {.base, contract, view.}
method transfer*(erc20: Erc20, recipient: Address, amount: UInt256) {.base, contract.}
method mint(token: TestToken, holder: Address, amount: UInt256): ?TransactionResponse {.base, contract.}

suite "Contracts":

  var token: TestToken
  var provider: JsonRpcProvider
  var snapshot: JsonNode
  var accounts: seq[Address]

  setup:
    provider = JsonRpcProvider.new("ws://localhost:8545")
    snapshot = await provider.send("evm_snapshot")
    accounts = await provider.listAccounts()
    let deployment = readDeployment()
    token = TestToken.new(!deployment.address(TestToken), provider)

  teardown:
    discard await provider.send("evm_revert", @[snapshot])

  test "can call constant functions":
    check (await token.name()) == "TestToken"
    check (await token.totalSupply()) == 0.u256
    check (await token.balanceOf(accounts[0])) == 0.u256
    check (await token.allowance(accounts[0], accounts[1])) == 0.u256

  test "can call non-constant functions":
    token = TestToken.new(token.address, provider.getSigner())
    discard await token.mint(accounts[1], 100.u256)
    check (await token.totalSupply()) == 100.u256
    check (await token.balanceOf(accounts[1])) == 100.u256

  test "can call non-constant functions without a signer":
    discard await token.mint(accounts[1], 100.u256)
    check (await token.balanceOf(accounts[1])) == 0.u256

  test "can call constant functions without a return type":
    token = TestToken.new(token.address, provider.getSigner())
    proc mint(token: TestToken, holder: Address, amount: UInt256) {.contract, view.}
    await mint(token, accounts[1], 100.u256)
    check (await balanceOf(token, accounts[1])) == 0.u256

  test "can call non-constant functions without a return type":
    token = TestToken.new(token.address, provider.getSigner())
    proc mint(token: TestToken, holder: Address, amount: UInt256) {.contract.}
    await token.mint(accounts[1], 100.u256)
    check (await balanceOf(token, accounts[1])) == 100.u256

  test "can call non-constant functions with a ?TransactionResponse return type":
    token = TestToken.new(token.address, provider.getSigner())
    proc mint(token: TestToken,
              holder: Address,
              amount: UInt256): ?TransactionResponse {.contract.}
    let txResp = await token.mint(accounts[1], 100.u256)
    check txResp is (?TransactionResponse)
    check txResp.isSome

  test "can call non-constant functions with a Confirmable return type":

    token = TestToken.new(token.address, provider.getSigner())
    proc mint(token: TestToken,
              holder: Address,
              amount: UInt256): Confirmable {.contract.}
    let txResp = await token.mint(accounts[1], 100.u256)
    check txResp is Confirmable
    check txResp.isSome

  test "fails to compile when function has an implementation":
    let works = compiles:
      proc foo(token: TestToken, bar: Address) {.contract.} = discard
    check not works

  test "fails to compile when function has no parameters":
    let works = compiles:
      proc foo() {.contract.}
    check not works

  test "fails to compile when non-constant function has a return type":
    let works = compiles:
      proc foo(token: TestToken, bar: Address): UInt256 {.contract.}
    check not works

  test "can connect to different providers and signers":
    let signer0 = provider.getSigner(accounts[0])
    let signer1 = provider.getSigner(accounts[1])
    discard await token.connect(signer0).mint(accounts[0], 100.u256)
    await token.connect(signer0).transfer(accounts[1], 50.u256)
    await token.connect(signer1).transfer(accounts[2], 25.u256)
    check (await token.connect(provider).balanceOf(accounts[0])) == 50.u256
    check (await token.connect(provider).balanceOf(accounts[1])) == 25.u256
    check (await token.connect(provider).balanceOf(accounts[2])) == 25.u256

  test "takes custom values for nonce, gasprice and gaslimit":
    let overrides = TransactionOverrides(
      nonce: some 100.u256,
      gasPrice: some 200.u256,
      gasLimit: some 300.u256
    )
    let signer = MockSigner.new(provider)
    discard await token.connect(signer).mint(accounts[0], 42.u256, overrides)
    check signer.transactions.len == 1
    check signer.transactions[0].nonce == overrides.nonce
    check signer.transactions[0].gasPrice == overrides.gasPrice
    check signer.transactions[0].gasLimit == overrides.gasLimit

  test "receives events when subscribed":
    var transfers: seq[Transfer]

    proc handleTransfer(transfer: Transfer) =
      transfers.add(transfer)

    let signer0 = provider.getSigner(accounts[0])
    let signer1 = provider.getSigner(accounts[1])

    let subscription = await token.subscribe(Transfer, handleTransfer)
    discard await token.connect(signer0).mint(accounts[0], 100.u256)
    await token.connect(signer0).transfer(accounts[1], 50.u256)
    await token.connect(signer1).transfer(accounts[2], 25.u256)
    await subscription.unsubscribe()

    check transfers == @[
      Transfer(receiver: accounts[0], value: 100.u256),
      Transfer(sender: accounts[0], receiver: accounts[1], value: 50.u256),
      Transfer(sender: accounts[1], receiver: accounts[2], value: 25.u256)
    ]

  test "stops receiving events when unsubscribed":
    var transfers: seq[Transfer]

    proc handleTransfer(transfer: Transfer) =
      transfers.add(transfer)

    let signer0 = provider.getSigner(accounts[0])

    let subscription = await token.subscribe(Transfer, handleTransfer)
    discard await token.connect(signer0).mint(accounts[0], 100.u256)
    await subscription.unsubscribe()

    await token.connect(signer0).transfer(accounts[1], 50.u256)

    check transfers == @[Transfer(receiver: accounts[0], value: 100.u256)]

  test "can wait for contract interaction tx to be mined":
    # must not be awaited so we can get newHeads inside of .wait
    let futMined = provider.mineBlocks(10)

    let signer0 = provider.getSigner(accounts[0])
    let receipt = await token.connect(signer0)
                    .mint(accounts[1], 100.u256)
                    .confirm(3) # wait for 3 confirmations
    let endBlock = await provider.getBlockNumber()

    check receipt.blockNumber.isSome # was eventually mined

    # >= 3 because more blocks may have been mined by the time the
    # check in `.wait` was done.
    # +1 for the block the tx was mined in
    check (endBlock - !receipt.blockNumber) + 1 >= 3

    await futMined