import * as ethers from 'ethers';

import type { Config } from '@app/config';

import { assert } from '@app/error';

import type { TransactionResponse } from '@ethersproject/providers';

import { parseUnits } from '@ethersproject/units';

export async function withdraw(amount: number, config: Config): Promise<TransactionResponse> {

  assert(config.signer);

  const faucet = new ethers.Contract(

    config.radToken.faucet,

    config.abi.faucet,

    config.signer

  );

  return faucet.withdraw(config.radToken.address, ethers.utils.parseUnits(amount.toString()));

}

export async function getMaxWithdrawAmount(config: Config): Promise<ethers.BigNumber> {

  assert(config.signer);

  const faucet = new ethers.Contract(

    config.radToken.faucet,

    config.abi.faucet,

    config.signer

  );

  return faucet.maxWithdrawAmount();

}

export async function calculateTimeLock(amount: ethers.BigNumber, config: Config): Promise<ethers.BigNumber> {

  assert(config.signer);

  const faucet = new ethers.Contract(

    config.radToken.faucet,

    config.abi.faucet,

    config.signer

  );

  return faucet.calculateTimeLock(parseUnits(amount.toString()));

}

export async function lastWithdrawalByUser(config: Config): Promise<ethers.BigNumber> {

  assert(config.signer);

  const address = config.signer.getAddress();

  const faucet = new ethers.Contract(

    config.radToken.faucet,

    config.abi.faucet,

    config.signer

  );

  return faucet.lastWithdrawalByUser(address);

}

  import { getMaxWithdrawAmount, lastWithdrawalByUser, calculateTimeLock } from "./Faucet";

    if (state === true) navigate("/faucet/submit", { state: { amount } });

  import Submit from "./Submit.svelte";

<Route path="faucet/submit">

  <Submit {config} />

<script lang="ts">

  import { onMount } from "svelte";

  import { navigate } from "svelte-routing";

  import type { Config } from "@app/config";

  import Loading from "@app/Loading.svelte";

  import Modal from "@app/Modal.svelte";

  import Err from "@app/Error.svelte";

  import { Status, State } from "@app/utils";

  import { withdraw } from "./Faucet";

  import { session } from '@app/session';

  export let config: Config;

  let error: Error;

  let state: State = {

    status: Status.Failed,

    error: "Error withdrawing, something happened.",

  };

  $: requester = ($session && $session.address);

  const back = () => navigate(`/faucet`);

  onMount(async () => {

    try {

      state.status = Status.Signing;

      const tx = await withdraw(window.history.state.amount, config);

      state.status = Status.Pending;

      await tx.wait();

      state.status = Status.Success;

    } catch (e) {

      console.error(e);

      error = e;

      state = { status: Status.Failed, error: e.message };

    }

  });

</script>

<style>

  .loader {

    display: flex;

    flex-direction: column;

    align-items: center;

  }

</style>

{#if error}

  <Err

    title="Transaction failed"

    message={error.message}

    on:close={() => navigate("/faucet")}

  />

{:else}

  <Modal>

    <span slot="title">

      {#if state.status === Status.Success}

        <div>🎉</div>

      {:else}

        <div>🌐</div>

      {/if}

      Withdrawal

    </span>

    <span slot="subtitle">

      {#if state.status === Status.Signing}

        Signing transaction. Please confirm in your wallet.

      {:else if state.status === Status.Pending}

        Awaiting transaction.

      {/if}

    </span>

    <span slot="body" class="loader">

      {#if state.status === Status.Success}

        The amount of {window.history.state.amount.toString()} RAD tokens has been successfully transfered to

        <span class="highlight">{requester}</span>

      {:else}

        <Loading small center />

      {/if}

    </span>

    <span slot="actions">

      {#if state.status === Status.Success}

        <button on:click={back} class="register"> Back </button>

      {/if}

    </span>

  </Modal>

{/if}