import { Signer } from 'ethers';
import { ReyaChainId, getReyaDomain } from '@reyaxyz/common';
import { JsonRpcSigner } from 'ethers';

export type SignClaimOrLockParams = {
  signer: Signer;
  distributorContract: string;
  merkleRoot: string;
  isLocking: boolean;
};

export type SignedClaimOrLock = {
  signature: string;
  signatureDeadline: number;
};

export const signClaimOrLock = async (
  params: SignClaimOrLockParams,
): Promise<SignedClaimOrLock> => {
  const network = await params.signer.provider?.getNetwork();
  if (!network) {
    throw new Error('Claim/Lock failed. Network not found.');
  }

  const reyaChainId = Number(network.chainId);
  if (!Object.values(ReyaChainId).includes(reyaChainId)) {
    throw new Error('Not on Reya Network.');
  }

  const wallet = await params.signer.getAddress();
  const deadline = Math.floor(Date.now() / 1000) + 15;

  const signature = await signClaimOrLockBySig(
    params.signer,
    reyaChainId,
    params.distributorContract,
    wallet,
    params.merkleRoot,
    params.isLocking,
    deadline,
  );

  return { signature, signatureDeadline: deadline };
};

async function signClaimOrLockBySig(
  signer: Signer | JsonRpcSigner,
  reyaChainId: ReyaChainId,
  distributorContract: string,
  wallet: string,
  merkleRoot: string,
  isLocking: boolean,
  deadline: number,
): Promise<string> {
  const types = {
    ClaimOrLockBySig: [
      { name: 'verifyingChainId', type: 'uint256' },
      { name: 'wallet', type: 'address' },
      { name: 'root', type: 'bytes32' },
      { name: 'isLocking', type: 'bool' },
      { name: 'deadline', type: 'uint256' },
    ],
  };
  const values = {
    verifyingChainId: reyaChainId,
    wallet: wallet,
    root: merkleRoot,
    isLocking: isLocking,
    deadline: deadline,
  };

  const domain = getReyaDomain(distributorContract);

  const signatureString = await signer.signTypedData(domain, types, values);

  return signatureString;
}