const { web3 } = require("hardhat");
const { expect } = require("chai");
const { ethers } = require("hardhat");
const { defaultAbiCoder } = require("ethers/lib/utils");
const { isConstructorDeclaration } = require("typescript");

var ToBig = (x) => ethers.BigNumber.from(x);
let ETH = ethers.BigNumber.from(10).pow(18);

describe("Hub V3 Test", function () {


    it("Hub Access Control", async function () {
      const hubfacFac = await ethers.getContractFactory("HubFactory");
      const hubFac = await hubfacFac.deploy(false);
      await hubFac.deployed();
  
      await hubFac.newHubImp();
  
      expect(await hubFac.createHub(true)).to.emit(hubFac,"CreateHub");
      let hub = await hubFac.hubs(0);
      console.log(hub);
      let git3 = await ethers.getContractAt("Hubv3",hub)
        let [singer,manager1,manager2,con1,con2,repoCon1,repoCon2] = await ethers.getSigners();
      

        let [IsAdmin,IsManager,IsContributor] = await git3.memberRole(singer.address);
        expect(IsAdmin).to.equal(true);
        expect(IsManager).to.equal(true);
        expect(IsContributor).to.equal(false);

        let ADMIN_ROLE = await git3.DEFAULT_ADMIN_ROLE();
        let addrs = await git3.roleToMembers(ADMIN_ROLE);
        expect(addrs[0]).to.equal(singer.address);

        await git3.addManager(manager1.address)
        await git3.addManager(manager2.address)
        let roles = await git3.memberRole(manager1.address)
        expect(roles[0]).to.equal(false);
        expect(roles[1]).to.equal(true);
        expect(roles[2]).to.equal(false);

        let MANAGER_ROLE = await git3.MANAGER();
        let m_addrs = await git3.roleToMembers(MANAGER_ROLE);
        expect(m_addrs[0]).to.equal(singer.address);
        expect(m_addrs[1]).to.equal(manager1.address);
        expect(m_addrs[2]).to.equal(manager2.address);


        roles = await git3.memberRole(manager2.address)
        expect(roles[0]).to.equal(false);
        expect(roles[1]).to.equal(true);
        expect(roles[2]).to.equal(false);

        await git3.removeManager(manager2.address)
        roles = await git3.memberRole(manager2.address)
        expect(roles[0]).to.equal(false);
        expect(roles[1]).to.equal(false);
        expect(roles[2]).to.equal(false);
        m_addrs = await git3.roleToMembers(MANAGER_ROLE);
        expect(m_addrs.length).to.equal(2);
        expect(m_addrs[0]).to.equal(singer.address);
        expect(m_addrs[1]).to.equal(manager1.address);

        // power no enough
        await expect(
            git3.connect(manager2).addContributor(con1.address)
            ).to.be.reverted


        await git3.connect(manager1).addContributor(con1.address)
        await git3.connect(manager1).addContributor(con2.address)

        roles = await git3.memberRole(con1.address)
        expect(roles[0]).to.equal(false);
        expect(roles[1]).to.equal(false);
        expect(roles[2]).to.equal(true);

        roles = await git3.memberRole(con2.address)
        expect(roles[0]).to.equal(false);
        expect(roles[1]).to.equal(false);
        expect(roles[2]).to.equal(true);
        
        await git3.connect(manager1).removeContributor(con2.address)
        roles = await git3.memberRole(con2.address)
        expect(roles[0]).to.equal(false);
        expect(roles[1]).to.equal(false);
        expect(roles[2]).to.equal(false);
        
        const repoName = "0x616263"
        await git3.connect(con1).createRepo(repoName)
        let repoOwner = await git3.connect(con1).repoOwner(repoName)
        expect(repoOwner).to.equal(con1.address)
        
        await git3.connect(con1).addRepoContributor(repoName,repoCon1.address)
        await git3.connect(con1).addRepoContributor(repoName,repoCon2.address)
        let cons = await git3.connect(con1).repoContributors(repoName)
        expect(cons[0]).to.equal(repoCon1.address)
        expect(cons[1]).to.equal(repoCon2.address)

        const branchPath = "0x2244"
        const branchRefHash = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
        const branchRefHash1 = "0x111aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
        const branchRefHash2 = "0x222aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
        const emptyRefHash = "0x0000000000000000000000000000000000000000"

        const anotherBranchPath = "0x6644"
        const anotherBranchRefHash = "0xffffaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
        await expect(
            git3.connect(singer).setRepoRef(repoName,branchPath,branchRefHash)
        ).to.be.reverted

        await git3.connect(repoCon1).setRepoRef(repoName,branchPath,branchRefHash)
        expect(await git3.getRepoRef(repoName,branchPath)).to.eq(branchRefHash)

        await git3.connect(repoCon1).setRepoRef(repoName,branchPath,branchRefHash1)
        expect(await git3.getRepoRef(repoName,branchPath)).to.eq(branchRefHash1)

        await git3.connect(repoCon2).setRepoRef(repoName,branchPath,branchRefHash2)
        expect(await git3.getRepoRef(repoName,branchPath)).to.eq(branchRefHash2)
        
        await git3.connect(repoCon1).delRepoRef(repoName,branchPath)
        expect(await git3.getRepoRef(repoName,branchPath)).to.eq(emptyRefHash)

        await git3.connect(con1).setRepoRef(repoName,anotherBranchPath,anotherBranchRefHash)
        expect(await git3.getRepoRef(repoName,anotherBranchPath)).to.eq(anotherBranchRefHash)
        
        let refs = await git3.listRepoRefs(repoName);
        console.log(refs);

    })


  it("upload/download/remove", async function () {
    const hubfacFac = await ethers.getContractFactory("HubFactory");
    const hubFac = await hubfacFac.deploy(true);
    await hubFac.deployed();

    await hubFac.newHubImp();

    expect(await hubFac.createHub(true)).to.emit(hubFac,"CreateHub");
    let hub = await hubFac.hubs(0);
    console.log(hub);
    let git3 = await ethers.getContractAt("Hubv3",hub)

    let singer;
    [singer] = await ethers.getSigners();
    const repoName = Buffer.from("test");

    await git3.createRepo(repoName);

    await git3.upload(repoName, "0x616263", "0x112233");
    expect(await git3.download(repoName, "0x616263")).to.eql([
      "0x112233",
      true,
    ]);

    let data = Array.from({ length: 40 }, () =>
      Math.floor(Math.random() * 256)
    );

    await git3.upload(repoName, "0x616263", data);
    expect(await git3.download(repoName, "0x616263")).to.eql([
      ethers.utils.hexlify(data),
      true,
    ]);

    // expect(await git3.size(repoName, "0x616263")).to.eql([ToBig(40), ToBig(1)]);

    // await git3.remove(repoName, "0x616263");
    // expect(await git3.size(repoName, "0x616263")).to.eql([ToBig(0), ToBig(0)]);
  });

  it("set/update/list/remove Branch", async function () {
    const hubfacFac = await ethers.getContractFactory("HubFactory");
    const hubFac = await hubfacFac.deploy(true);
    await hubFac.deployed();

    await hubFac.newHubImp();

    expect(await hubFac.createHub(true)).to.emit(hubFac,"CreateHub");
    let hub = await hubFac.hubs(0);
    console.log(hub);
    let git3 = await ethers.getContractAt("Hubv3",hub)

    let repoName = Buffer.from("test");
    await git3.createRepo(repoName);

    function concatHexStr(s1, s2) {
      return "0x" + Buffer.concat([s1, Buffer.from("/"), s2]).toString("hex");
    }

    let key0 = Buffer.from("refs/heads/master");
    let data0 = "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
    await git3.setRepoRef(repoName, key0, data0);

    let key1 = Buffer.from("refs/heads/dev");
    let data1 = "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
    await git3.setRepoRef(repoName, key1, data1);

    let key2 = Buffer.from("refs/heads/main");
    let data2 = "0xcccccccccccccccccccccccccccccccccccccccc";
    await git3.setRepoRef(repoName, key2, data2);

    let refs = await git3.listRepoRefs(repoName);
    expect(refs[0]).to.eql([data0, concatHexStr(repoName, key0)]);
    expect(refs[1]).to.eql([data1, concatHexStr(repoName, key1)]);
    expect(refs[2]).to.eql([data2, concatHexStr(repoName, key2)]);
    expect(refs.length).to.eql(3);

    // check delRef
    await git3.delRepoRef(repoName, key0);
    refs = await git3.listRepoRefs(repoName);
    expect(refs[0]).to.eql([data2, concatHexStr(repoName, key2)]);
    expect(refs[1]).to.eql([data1, concatHexStr(repoName, key1)]);
    expect(refs.length).to.eql(2);

    await git3.delRepoRef(repoName, key1);
    refs = await git3.listRepoRefs(repoName);
    expect(refs[0]).to.eql([data2, concatHexStr(repoName, key2)]);
    expect(refs.length).to.eql(1);

    // check update
    let data3 = "0xdddddddddddddddddddddddddddddddddddddddd";
    await git3.setRepoRef(repoName, key2, data3);
    refs = await git3.listRepoRefs(repoName);
    expect(refs[0]).to.eql([data3, concatHexStr(repoName, key2)]);
  });

  it("HubFactory", async function () {

    const hubfacFac = await ethers.getContractFactory("HubFactory");
    const hubFac = await hubfacFac.deploy(true);
    await hubFac.deployed();

    await hubFac.newHubImp();

    expect(await hubFac.createHub(true)).to.emit(hubFac,"CreateHub");
    let hub = await hubFac.hubs(0);
    console.log(hub);
    let git3 = await ethers.getContractAt("Hubv3",hub)
  })

  

});