// the handler

const handleTransfer = async ({
  event,
  context,
}: {
  event: eventLog<Hub_HubTransfer_eventArgs | PersonalCRC_Transfer_eventArgs>;
  context: handlerContext;
}) => {
  const entity: Hub_Transfer = {
    id: event.transaction.hash,
    from: event.params.from,
    to: event.params.to,
    amount: event.params.amount,
  };

  context.Hub_Transfer.set(entity);

  const personalCRC = await context.Hub_PersonalCRC.get(event.params.to);
  let newBalance = event.params.amount;
  if (personalCRC) {
    newBalance += personalCRC.balance;
  }
  context.Hub_PersonalCRC.set({
    id: event.params.to,
    balance: newBalance,
  });
  if (event.params.from !== zeroAddress) {
    const personalCRC = await context.Hub_PersonalCRC.get(event.params.from);
    let newBalance = event.params.amount;
    if (personalCRC) {
      newBalance -= personalCRC.balance;
    }
    context.Hub_PersonalCRC.set({
      id: event.params.from,
      balance: newBalance,
    });
  }
};

PersonalCRC.Transfer.handler(handleTransfer);

Hub.HubTransfer.handler(handleTransfer);



// the test


describe("Transfer", () => {
  const mockDb = MockDb.createMockDb();

  it("Signup and Transfer", async () => {
    // signup
    const eventUser1 = Hub.Signup.createMockEvent({
      token,
      user: user1,
    });
    await Hub.Signup.processEvent({
      event: eventUser1,
      mockDb,
    });
    const eventUser2 = Hub.Signup.createMockEvent({
      token: token2,
      user: user2,
    });
    await Hub.Signup.processEvent({
      event: eventUser2,
      mockDb,
    });
    // initial funds
    const eventFundUser1 = Hub.HubTransfer.createMockEvent({
      amount: parseEther("20"),
      from: zeroAddress,
      to: user1,
    });
    await Hub.HubTransfer.processEvent({
      event: eventFundUser1,
      mockDb,
    });
    const eventFundUser2 = Hub.HubTransfer.createMockEvent({
      amount: parseEther("20"),
      from: zeroAddress,
      to: user2,
    });
    await Hub.HubTransfer.processEvent({
      event: eventFundUser2,
      mockDb,
    });

    // actual test
    const eventTransfer = Hub.HubTransfer.createMockEvent({
      amount: parseEther("5"),
      from: user1,
      to: user2,
    });
    const mockDbUpdated = await Hub.HubTransfer.processEvent({
      event: eventTransfer,
      mockDb,
    });

    let actualPersonalCRCUser1 = mockDbUpdated.entities.Hub_PersonalCRC.get(user1);
    let actualPersonalCRCUser2 = mockDbUpdated.entities.Hub_PersonalCRC.get(user2);
    let actualHubHubTransfer = mockDbUpdated.entities.Hub_Transfer.get(
      `${eventTransfer.transaction.hash}`
    );

    const expectedPersonalCRCUser1 = {
      id: user1,
      balance: parseEther("15"),
    };
    const expectedPersonalCRCUser2 = {
      id: user2,
      balance: parseEther("25"),
    };
    const expectedHubHubTransfer: Hub_Transfer = {
      id: `${eventTransfer.transaction.hash}`,
      amount: parseEther("5"),
      from: user1,
      to: user2,
    };
    // Asserting that the entity in the mock database is the same as the expected entity
    assert.deepEqual(
      actualHubHubTransfer,
      expectedHubHubTransfer,
      "Actual HubHubTransfer should be the same as the expectedHubHubTransfer"
    );
    assert.deepEqual(
      actualPersonalCRCUser1,
      expectedPersonalCRCUser1,
      "Actual PersonalCRC1 should be the same as the expectedPersonalCRC1"
    );
    assert.deepEqual(
      actualPersonalCRCUser2,
      expectedPersonalCRCUser2,
      "Actual PersonalCRC2 should be the same as the expectedPersonalCRC2"
    );
  });
});