import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
import chai from 'chai';
import chaiAsPromised from 'chai-as-promised';
import { BigNumber } from 'ethers';
import { ethers } from 'hardhat';
import { ForwarderDeployer } from '../scripts/deployers/ForwarderDeployer';
import { VenueRegistarDeployer } from '../scripts/deployers/VenueRegistarDeployer';
import { toETH, toUSDC } from './utils';
import { USDCDeployer } from '../scripts/deployers/USDCDeployer';
import { ERC721EFactoryDeployer } from '../scripts/deployers/ERC721EFactoryDeployer';
import {
  ERC721E,
  ERC721EFactory,
  ReservForwarder,
  PaymentSplitter,
  USDC,
  VenueFactory,
  VenueRegistar,
  VenueSBT,
} from '../types';
import { VenueFactoryDeployer } from '../scripts/deployers/VenueFactoryDeployer';
import { getLatestTimestamp } from '../scripts/time';

chai.use(chaiAsPromised);
const { expect } = chai;

let signer: SignerWithAddress;
let otherSigner: SignerWithAddress;
let seller: SignerWithAddress;
let buyer: SignerWithAddress;

let venueRegistar: VenueRegistar;
let usdc: USDC;
let forwarder: ReservForwarder;
let myVenue: VenueSBT;
let erc721EFactory: ERC721EFactory;
let myEvent: ERC721E;
let splitter: PaymentSplitter;

describe('Payment Splitter', function () {
  let saleEnd: number;
  let timestamp: number;
  before(async () => {
    [signer, otherSigner, seller, buyer] = await ethers.getSigners();
  });

  beforeEach(async () => {
    const USDC = new USDCDeployer(signer);
    usdc = await USDC.deploy({
      name: 'USDC',
      symbol: 'USDC',
    });

    const venueRegistarDeployer = new VenueRegistarDeployer(signer);
    venueRegistar = await venueRegistarDeployer.deployAndInitialize(toETH(1), signer.address);

    const VenueFactory = new VenueFactoryDeployer(signer);
    const venueFactory = (await VenueFactory.deploy(venueRegistar.address)) as VenueFactory;

    await venueRegistar.functions.setVenueFactory(venueFactory.address);

    await venueRegistar.functions.setVenueSBTVersion('1.0.0-beta.0+fob.rsv.iVenueSBT');

    const ReservForwarder = new ForwarderDeployer(signer);
    forwarder = await ReservForwarder.deployAndInitialize({
      venueRegistar: venueRegistar.address,
    });

    await venueRegistar.functions.setForwarder(forwarder.address);

    await venueRegistar.functions.whitelistPaymentToken(usdc.address, true);

    const erc721EFactoryDeployer = new ERC721EFactoryDeployer(signer);
    erc721EFactory = await erc721EFactoryDeployer.deploy({
      forwarder: forwarder.address,
    });

    await forwarder.functions.addfactory(erc721EFactory.address);
    expect(await forwarder.getFactoryAt(1)).to.be.equal(erc721EFactory.address);

    await venueRegistar.functions.ownerDeployVenue('Santiagos', 'SDV', 'sdv.com/', otherSigner.address);
    const venues = await venueRegistar.getVenues();

    myVenue = (await ethers.getContractAt('VenueSBT', venues[0], otherSigner)) as VenueSBT;

    const splitterAdd = await venueRegistar.splitterByVenue(myVenue.address);
    splitter = (await ethers.getContractAt('PaymentSplitter', splitterAdd)) as PaymentSplitter;

    const factoryType = await forwarder.getFactoryPosition(erc721EFactory.address);

    timestamp = (await getLatestTimestamp()).toNumber();
    const abi = ethers.utils.defaultAbiCoder;
    const extraData = abi.encode(['uint256'], [timestamp + 100]);

    let tx = await (
      await myVenue.functions.mint(factoryType, 'MyEvent', 'MEV', 'www.sdv.mev.com/', usdc.address, extraData)
    ).wait();

    const event = tx.events?.find((e) => e.event === 'NewEvent')?.args?._event;
    myEvent = (await ethers.getContractAt('ERC721E', event)) as ERC721E;

    saleEnd = timestamp + 60;

    tx = await (await myEvent.connect(otherSigner).functions.createEntry('VIP', toUSDC(100), 10, 10, saleEnd)).wait();
    let entryPos = tx.events?.find((e) => e.event === 'NewEntry')?.args?.pos as BigNumber;

    await usdc.functions.mint(seller.address, toUSDC(1000));
    await usdc.connect(seller).functions.approve(myEvent.address, toUSDC(1000));
    const prices = new Array(10).fill(toUSDC(150));

    await myEvent.connect(seller).buyTickets(seller.address, 123, entryPos, 10, prices);
  });

  it('Splits on secondary sales', async () => {
    expect(await usdc.balanceOf(splitter.address)).to.be.equal(0);

    await usdc.functions.mint(buyer.address, toUSDC(1500));
    await usdc.connect(buyer).functions.approve(myEvent.address, toUSDC(1500));
    const tokensToBuy = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
    const newPrices: Array<BigNumber> = new Array(10).fill(toUSDC(200));

    const buyerBeforeBalance = await usdc.balanceOf(buyer.address);
    const sellerBeforeBalance = await usdc.balanceOf(seller.address);

    await myEvent.connect(buyer).functions.buyBatch(tokensToBuy, newPrices);

    const totalPaid = toUSDC(150).mul(10);
    expect(await usdc.balanceOf(buyer.address)).to.be.equal(buyerBeforeBalance.sub(totalPaid));
    expect(await usdc.balanceOf(seller.address)).to.be.equal(
      sellerBeforeBalance.add(totalPaid.sub(totalPaid.mul(10).div(100))),
    ); //minus 10%

    const splitterBalance = totalPaid.sub(totalPaid.mul(90).div(100));
    expect(await usdc.balanceOf(splitter.address)).to.be.equal(splitterBalance); //minus 90%

    expect(await splitter['releasable(address,address)'](usdc.address, signer.address)).to.be.equal(
      splitterBalance.mul(36).div(100),
    );
    expect(await splitter['releasable(address,address)'](usdc.address, myVenue.address)).to.be.equal(
      splitterBalance.mul(64).div(100),
    );

    const signerBalanceBefore = await usdc.balanceOf(signer.address);
    const venueRevenueReceiverBalanceBefore = await usdc.balanceOf(myVenue.address);

    await splitter.functions['release(address,address)'](usdc.address, signer.address);
    await splitter.functions['release(address,address)'](usdc.address, myVenue.address);

    expect(await usdc.balanceOf(signer.address)).to.be.equal(signerBalanceBefore.add(splitterBalance.mul(36).div(100)));
    expect(await usdc.balanceOf(myVenue.address)).to.be.equal(
      venueRevenueReceiverBalanceBefore.add(splitterBalance.mul(64).div(100)),
    );
  });
});