import chai, { expect } from 'chai';
import { Signer } from 'ethers';
import { solidity } from 'ethereum-waffle';
import { ethers } from 'hardhat';
import {
	MockToken,
	MockToken__factory,
	MockStake,
	MockStake__factory,
	MockRewarder,
	MockRewarder__factory,
	MockElection,
	MockElection__factory,
	MockMajorCandidates,
	MockMajorCandidates__factory,
	MockSlasher,
	MockSlasher__factory
} from '../types';

import { oneToken, increaseTime, AddressZero } from './utils'

chai.use(solidity);

describe("MajorCandidates tests", () => {
	let signers: Signer[];
	let token: MockToken;
	let stake: MockStake;
	let rewarder: MockRewarder;
	let election: MockElection;
	let slasher: MockSlasher;
	let majorCandidates: MockMajorCandidates;

	const rewardPerSecond = oneToken.mul(40)

	beforeEach(async () => {
		signers = await ethers.getSigners();
		token = await new MockToken__factory(signers[0]).deploy();
		stake = await new MockStake__factory(signers[0]).deploy();
		rewarder = await new MockRewarder__factory(signers[0]).deploy();
		election = await new MockElection__factory(signers[0]).deploy();
		majorCandidates = await new MockMajorCandidates__factory(signers[0]).deploy();
		slasher = await new MockSlasher__factory(signers[0]).deploy();
		await token.transfer(rewarder.address, oneToken.mul(1e7))
		await rewarder.init(token.address, [stake.address, election.address])
		await stake.init(token.address, rewarder.address, election.address, majorCandidates.address, slasher.address, 60 * 10, 100, rewardPerSecond)
		await election.init(token.address, rewarder.address, stake.address, majorCandidates.address)
		await majorCandidates.init(stake.address, election.address)
		const amount = oneToken.mul(1000)
		let last = ''
		for (let i = 0; i < 10; i++) {
			const signer = await signers[i].getAddress()
			await token.transfer(signer, oneToken.mul(1e6))
			await token.connect(signers[i]).approve(stake.address, oneToken.mul(1e6))
			const manifest = `candidate manifest ${i}`
			await stake.connect(signers[i]).registerAndStake(amount, manifest)
			const votes = oneToken.mul((10-i)*100)
			await token.connect(signers[i]).approve(election.address, oneToken.mul(1e6))
			await election.connect(signers[i]).vote(signer, signer, votes, !!last ? last : AddressZero, 10)
			last = signer
		}
	});

	it('major candidates exists', async () => {
		const majors = await majorCandidates.majorCandidateList()
		expect(majors.length != 0, 'nonexistent major candidates')
	});

	it('major head changed', async () => {
		const signer = await signers[0].getAddress()
		await election.withdrawAndClaim(signer, oneToken.mul(1000), signer, signer, 10)
		const headCandidate = await majorCandidates.headCandidate()
		const signer1 = await signers[1].getAddress()
		expect(signer1 == headCandidate, 'invalid candidates order')
	});

	it('major tail changed', async () => {
		const tail = await majorCandidates.tailCandidate()
		const votes = await election.voteSupply(tail)
		await election.connect(signers[9]).withdrawAndClaim(tail, votes, tail, tail, 10)
		const tailCandidate = await majorCandidates.tailCandidate()
		expect(tailCandidate != tail, 'invalid candidates order')
	});

});