/**
 * @jest-environment jsdom
 */
import "../../__tests__/test-helpers/dom-polyfill";
import { setSupportedCurrencies } from "../../currencies/index";
setSupportedCurrencies(["tron"]);
import { renderHook, act } from "@testing-library/react";
import { useTronSuperRepresentatives, getLastVotedDate, getNextRewardDate, formatVotes, useSortedSr, getUnfreezeData, } from "./react";
import { __NEXT_REWARD_DATE__, __LAST_VOTING_DATE__, mockAccount, mockAccountNoReward, mockAccountNoVote, mockAccountV2, } from "./data.mock";
import superRepresentatives from "@ledgerhq/coin-tron/network/superRepresentativesData.mock";
jest.mock("@ledgerhq/coin-tron/network", () => {
    return {
        getTronSuperRepresentatives: jest.fn().mockImplementation(() => {
            return Promise.resolve(superRepresentatives);
        }),
    };
});
jest.mock("@ledgerhq/coin-tron/logic/utils", () => {
    return {
        extractBandwidthInfo: jest.fn().mockImplementation(() => {
            return {
                freeUsed: 0,
                freeLimit: 0,
                gainedUsed: 0,
                gainedLimit: 0,
            };
        }),
    };
});
test("Tron SuperRepresentatives hook - useTronSuperRepresentatives - Expect super representatives list", async () => {
    const { result } = renderHook(() => useTronSuperRepresentatives());
    await act(async () => {
        expect(result.current).toStrictEqual([]);
    });
    process.nextTick(() => expect(result.current).toStrictEqual(superRepresentatives));
});
test("Tron get last voting date - getLastVotedDate - Expect to get last voted date", () => {
    expect(getLastVotedDate(mockAccount)).toStrictEqual(__LAST_VOTING_DATE__);
    expect(getLastVotedDate(mockAccountNoVote)).toStrictEqual(null);
});
test("Tron get next reward date - getNextRewardDate - Expect to get next reward date", () => {
    expect(getNextRewardDate(mockAccount)).toStrictEqual(__NEXT_REWARD_DATE__.valueOf() + 24 * 60 * 60 * 1000);
    expect(getNextRewardDate(mockAccountNoReward)).toStrictEqual(null);
});
const __VOTES__ = superRepresentatives.slice(0, 2).map(({ address }) => ({
    address,
    voteCount: 100,
}));
const __FORMATTED_VOTES__ = superRepresentatives.slice(0, 2).map((validator, i) => ({
    address: validator.address,
    voteCount: 100,
    validator,
    rank: i + 1,
    isSR: true,
}));
test("Tron format votes - formatVotes - Expect to get formatted votes", () => {
    expect(formatVotes(undefined, superRepresentatives)).toStrictEqual([]);
    expect(formatVotes(__VOTES__, superRepresentatives)).toStrictEqual(__FORMATTED_VOTES__);
});
const SR_INDEX_1 = 9;
const SR_INDEX_2 = 2;
const VOTE_AMOUNT_1 = 10;
const VOTE_AMOUNT_2 = 50;
const votes = [
    {
        address: superRepresentatives[SR_INDEX_1].address,
        voteCount: VOTE_AMOUNT_1,
    },
    {
        address: superRepresentatives[SR_INDEX_2].address,
        voteCount: VOTE_AMOUNT_2,
    },
];
test("Tron search SR - search SR in the list - Expect to retrieve a specific list SR", () => {
    const { result } = renderHook(() => useSortedSr(superRepresentatives[SR_INDEX_1].name, 
    // @ts-expect-error wat
    superRepresentatives, votes));
    act(() => {
        expect(Array.isArray(result.current)).toBe(true);
        expect(result.current[0].address).toBe(superRepresentatives[SR_INDEX_1].address);
    });
});
test("Tron search SR - search SR in the list - Expect to retrieve all the list if no search provided and sorted by votes", () => {
    const { result } = renderHook(() => useSortedSr("", superRepresentatives, votes));
    act(() => {
        expect(Array.isArray(result.current)).toBe(true);
        expect(result.current.length).toBe(superRepresentatives.length);
        expect(result.current[0].address).toBe(votes[1].address);
        expect(result.current[1].address).toBe(votes[0].address);
    });
});
test("Tron unfreeze - get unfreeze data - Expect to retrieve unfreeze data from account", () => {
    const { unfreezeBandwidth, unfreezeEnergy, canUnfreezeBandwidth, canUnfreezeEnergy } = getUnfreezeData(mockAccountV2);
    expect(unfreezeBandwidth.toString()).toBe("539000000");
    expect(unfreezeEnergy.toString()).toBe("28877000");
    expect(canUnfreezeBandwidth).toBe(true);
    expect(canUnfreezeEnergy).toBe(true);
});
//# sourceMappingURL=react.test.js.map