const { expect } = require('chai');
const { ethers } = require('hardhat');

describe('GreeterFactory', function () {
  let GreeterFactory, greeterFactory;
  let owner, user1, user2;
  const INITIAL_GREETING = 'Hello, Chunk Network!';
  const NEW_GREETING = 'Updated Greeting for Testing';

  beforeEach(async function () {
    [owner, user1, user2] = await ethers.getSigners();

    const GreeterFactoryContract = await ethers.getContractFactory('GreeterFactory');
    greeterFactory = await GreeterFactoryContract.deploy();
    await greeterFactory.deployed();
  });

  describe('Greeter Creation', function () {
    it('should create a new Greeter contract with initial greeting', async function () {
      const tx = await greeterFactory.connect(user1).createGreeter(INITIAL_GREETING);
      const receipt = await tx.wait();
      
      const greeterAddress = receipt.events.find(e => e.event === 'GreeterCreated').args.greeterAddress;
      const Greeter = await ethers.getContractAt('Greeter', greeterAddress);

      const currentGreeting = await Greeter.greet();
      expect(currentGreeting).to.equal(INITIAL_GREETING);
    });

    it('should track created Greeter contracts per user', async function () {
      await greeterFactory.connect(user1).createGreeter(INITIAL_GREETING);
      await greeterFactory.connect(user1).createGreeter(NEW_GREETING);

      const userGreeters = await greeterFactory.getUserGreeters(user1.address);
      expect(userGreeters.length).to.equal(2);
    });
  });

  describe('Greeting Modification', function () {
    let userGreeter;

    beforeEach(async function () {
      const tx = await greeterFactory.connect(user1).createGreeter(INITIAL_GREETING);
      const receipt = await tx.wait();
      
      const greeterAddress = receipt.events.find(e => e.event === 'GreeterCreated').args.greeterAddress;
      userGreeter = await ethers.getContractAt('Greeter', greeterAddress);
    });

    it('should allow owner to update greeting', async function () {
      await userGreeter.connect(user1).setGreeting(NEW_GREETING);
      const updatedGreeting = await userGreeter.greet();
      
      expect(updatedGreeting).to.equal(NEW_GREETING);
    });

    it('should prevent non-owners from updating greeting', async function () {
      await expect(
        userGreeter.connect(user2).setGreeting(NEW_GREETING)
      ).to.be.revertedWith('Only owner can update greeting');
    });
  });

  describe('Factory Limits', function () {
    it('should limit maximum Greeter contracts per user', async function () {
      const MAX_GREETERS = 5;
      
      for (let i = 0; i < MAX_GREETERS; i++) {
        await greeterFactory.connect(user1).createGreeter(`Greeting ${i}`);
      }

      await expect(
        greeterFactory.connect(user1).createGreeter('Extra Greeting')
      ).to.be.revertedWith('Maximum Greeter contracts reached');
    });
  });
});