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, 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 royaltyReceiver: SignerWithAddress;
let buyer: SignerWithAddress;
let venueRevenueReceiver: SignerWithAddress;

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

describe('ERC721A Operator', function () {
  let timestamp: number;
  let saleEnd: number;
  before(async () => {
    [signer, otherSigner, royaltyReceiver, buyer, venueRevenueReceiver] = 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 factoryType = await forwarder.getFactoryPosition(erc721EFactory.address);

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

    const 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;
  });

  describe('Save Tickets', () => {
    it('Saves tickets', async () => {
      const 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(buyer.address, toUSDC(1000));
      await usdc.connect(buyer).functions.approve(myEvent.address, toUSDC(1000));
      let prices: Array<BigNumber> = new Array(10).fill(toUSDC(150));
      prices = prices.map((p, i) => {
        return p.add(toUSDC(i + 1));
      });

      await expect(myEvent.connect(buyer).buyTickets(buyer.address, 123, entryPos, 10, prices))
        .to.emit(myEvent, 'MintTickets')
        .withArgs(buyer.address, 123, entryPos, 10);

      expect(await myEvent.priceByToken(9)).to.be.equal(toUSDC(160));
    });

    it('Fails if selling price is 0', async () => {
      const 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(buyer.address, toUSDC(1000));
      await usdc.connect(buyer).functions.approve(myEvent.address, toUSDC(1000));
      let prices: Array<BigNumber> = new Array(10).fill(toUSDC(150));
      prices[9] = BigNumber.from(0);

      await expect(myEvent.connect(buyer).buyTickets(buyer.address, 123, entryPos, 10, prices)).to.be.revertedWith(
        'ERC721AOPInvalidSellPrice',
      );
    });
  });

  describe('Set Selling Price', () => {
    it('Sets selling price', async () => {
      const 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(buyer.address, toUSDC(1000));
      await usdc.connect(buyer).functions.approve(myEvent.address, toUSDC(1000));
      const prices: Array<BigNumber> = new Array(10).fill(toUSDC(150));
      await myEvent.connect(buyer).buyTickets(buyer.address, 123, entryPos, 10, prices);

      const newPrices: Array<BigNumber> = new Array(5).fill(toUSDC(200));
      const tokensToSell = [0, 1, 2, 3, 4];

      await expect(myEvent.connect(buyer).functions.setSellingPrice(tokensToSell, newPrices))
        .to.emit(myEvent, 'SetSellPrice')
        .withArgs(0, toUSDC(200))
        .to.emit(myEvent, 'SetSellPrice')
        .withArgs(1, toUSDC(200))
        .to.emit(myEvent, 'SetSellPrice')
        .withArgs(2, toUSDC(200))
        .to.emit(myEvent, 'SetSellPrice')
        .withArgs(3, toUSDC(200))
        .to.emit(myEvent, 'SetSellPrice')
        .withArgs(4, toUSDC(200));

      expect(await myEvent.priceByToken(0)).to.be.equal(toUSDC(200));
    });

    it('Fails with wrong batch length', async () => {
      const 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(buyer.address, toUSDC(1000));
      await usdc.connect(buyer).functions.approve(myEvent.address, toUSDC(1000));
      const prices: Array<BigNumber> = new Array(10).fill(toUSDC(150));
      await myEvent.connect(buyer).functions.buyTickets(buyer.address, 123, entryPos, 10, prices);

      const newPrices: Array<BigNumber> = new Array(5).fill(toUSDC(200));
      const tokensToSell = [0, 1, 2, 3];

      await expect(myEvent.connect(buyer).functions.setSellingPrice(tokensToSell, newPrices)).to.be.revertedWith(
        'ERC721AOPWrongBatchLengths',
      );
    });

    it('Fails if user is not token owner', async () => {
      const 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(buyer.address, toUSDC(1000));
      await usdc.connect(buyer).functions.approve(myEvent.address, toUSDC(1000));
      const prices: Array<BigNumber> = new Array(10).fill(toUSDC(150));
      await myEvent.connect(buyer).functions.buyTickets(buyer.address, 123, entryPos, 10, prices);
      await myEvent.connect(buyer).functions.transferFrom(buyer.address, otherSigner.address, 0);

      const newPrices: Array<BigNumber> = new Array(5).fill(toUSDC(200));
      const tokensToSell = [0, 1, 2, 3, 4];

      await expect(myEvent.connect(buyer).functions.setSellingPrice(tokensToSell, newPrices)).to.be.revertedWith(
        'ERC721AOPNotOwnedToken',
      );
    });

    it('Fails if selling price is 0', async () => {
      const 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(buyer.address, toUSDC(1000));
      await usdc.connect(buyer).functions.approve(myEvent.address, toUSDC(1000));
      const prices: Array<BigNumber> = new Array(10).fill(toUSDC(150));
      await myEvent.connect(buyer).functions.buyTickets(buyer.address, 123, entryPos, 10, prices);

      let newPrices: Array<BigNumber> = new Array(5).fill(toUSDC(200));
      newPrices[4] = BigNumber.from(0);
      const tokensToSell = [0, 1, 2, 3, 4];

      await expect(myEvent.connect(buyer).functions.setSellingPrice(tokensToSell, newPrices)).to.be.revertedWith(
        'ERC721AOPInvalidSellPrice',
      );
    });
  });
});