const BEBadge = artifacts.require("BEBadgeV2");
const {
  BN,
  constants,
  expectEvent,
  expectRevert,
} = require("@openzeppelin/test-helpers");

contract("BEBadgeV2", (accounts) => {
  let badge;
  const owner = accounts[0];
  const user = accounts[1];
  const executor = accounts[2];

  beforeEach(async () => {
    badge = await BEBadge.new("CRYPTO ELITE'S HERO", "HERO", 3);
  });

  it("should batch mint two badges", async () => {
    await badge.batchMint(user, 2, { from: owner });
    const balanceOfUser = await badge.balanceOf(user);
    assert.equal(balanceOfUser, 2, "Incorrect user balance");
  });

  it("should revert batch minting two badges with not mint role", async () => {
    const mintRole = await badge.MINTER_ROLE();
    const err = `AccessControl: account ${(user+'').toLowerCase()} is missing role ${mintRole}`
    await expectRevert(
      badge.batchMint(user, 2, { from: user }),
      err
    );
  });

  it("should revert batch minting badges with not enough supply", async () => {
    const err = `Exceeds the total supply`
    await expectRevert(
      badge.batchMint(user, 4, { from: owner }),
      err
    );
  });

  it("should mint one badge", async () => {
    await badge.safeMint(user, { from: owner });
    const balanceOfUser = await badge.balanceOf(user);
    assert.equal(balanceOfUser, 1, "Incorrect user balance");
  });

  it("should revert minting one badge with not mint role", async () => {
    const mintRole = await badge.MINTER_ROLE();
    const err = `AccessControl: account ${(user+'').toLowerCase()} is missing role ${mintRole}`
    await expectRevert(
      badge.safeMint(user, { from: user }),
      err
    );
  });

  it("should burn one badge", async () => {
    await badge.safeMint(user, { from: owner });
    const tokenId = await badge.tokenOfOwnerByIndex(user, 0);
    await badge.burn(tokenId, { from: user });
    const balanceOfUser = await badge.balanceOf(user);
    assert.equal(balanceOfUser, 0, "Incorrect user balance");
  });

  it("should burn one badge with approval", async () => {
    await badge.safeMint(user, { from: owner });
    const tokenId = await badge.tokenOfOwnerByIndex(user, 0);
    const balanceOfUserTmp = await badge.balanceOf(user);
    assert.equal(balanceOfUserTmp, 1, "Incorrect user balance");
    await badge.approve(executor, tokenId, { from: user });
    await badge.burn(tokenId, { from: executor });
    const balanceOfUser = await badge.balanceOf(user);
    assert.equal(balanceOfUser, 0, "Incorrect user balance");
  });

  it("should revert burning one badge", async () => {
    const err = `ERC721: invalid token ID.`
    await expectRevert(
      badge.burn(1, { from: user }),
      err
    );
  });

  it("should revert burning one badge without approval", async () => {
    const err = `ERC721: caller is not token owner or approved.`
    await badge.safeMint(user, { from: owner });
    const tokenId = await badge.tokenOfOwnerByIndex(user, 0);
    await expectRevert(
      badge.burn(tokenId, { from: executor }),
      err
    );
  });
  
  it("should receive event for RoleGranted and RoleRevoked", async () => {
    const role = await badge.MINTER_ROLE();
    const receipt = await badge.grantRole(role, user, { from: owner });
    expectEvent(receipt, "RoleGranted", {
      account: user,
      role: role,
      sender: owner,
    });
    const receipt2 = await badge.revokeRole(role, user, { from: owner });
    expectEvent(receipt2, "RoleRevoked", {
      account: user,
      role: role,
      sender: owner,
    });
  });
});