import { Mapper } from "../analyticsMapper";
import { fixtures } from "./fixtures";

jest.mock("@applicaster/zapp-react-native-utils/appUtils/contextKeysManager");

const AnalyticsMapper = new Mapper();

/**
 * Fixture Pair composed of expected input and expected output
 * first = input
 * second = output
 */
type Pair = {
  first: any;
  second: any;
};

// Test Runner
const setConfigRunMapTest = async (rules, events) => {
  AnalyticsMapper.setConfiguration(rules);

  return await Promise.all(
    events.map(async (pair: Pair) => {
      const result = await AnalyticsMapper.map(pair.first);
      expect(result).toEqual(pair.second || null);
    })
  );
};

describe("Analytics Mapper", () => {
  it("Returns event modified by regex rename rule", async () => {
    const rules = fixtures.eventRegexRules;

    await setConfigRunMapTest(rules, fixtures.eventRegexEvents);
  });

  it("Returns event modified by rename rule", async () => {
    const rules = fixtures.renameRules;

    await setConfigRunMapTest(rules, fixtures.renameEvents);
  });

  it("Returns event modified by ignore param rule", async () => {
    const rules = fixtures.ignoredParamsRules;

    await setConfigRunMapTest(rules, fixtures.ignoredParamsEvents);
  });

  it("Returns event modified by ignore event rule", async () => {
    const rules = fixtures.ignoredEventRules;

    await setConfigRunMapTest(rules, fixtures.ignoredEventEvents);
  });

  it("Returns event modified by context event rule", async () => {
    const rules = fixtures.contextRules;

    await setConfigRunMapTest(rules, fixtures.contextEvents);
  });

  it("Returns event modified by block unlisted event rule", async () => {
    const rules = fixtures.blockUnlistedEventRules;

    await setConfigRunMapTest(rules, fixtures.blockUnlistedEventEvents);
  });

  it("Returns event modified by block unlisted param rule", async () => {
    const rules = fixtures.blockUnlistedParamRules;

    await setConfigRunMapTest(rules, fixtures.blockUnlistedParamEvents);
  });

  it("Returns event modified by Analytics Custom Property", async () => {
    const rules = fixtures.ACPEventRules;
    await setConfigRunMapTest(rules, fixtures.ACPEventEvents);
  });

  it("Does not let an ignore rule short-circuit later events", async () => {
    await setConfigRunMapTest(
      fixtures.ignoreOrderingRules,
      fixtures.ignoreOrderingEvents
    );
  });

  it("Keeps the original name when rename is empty", async () => {
    await setConfigRunMapTest(
      fixtures.emptyRenameRules,
      fixtures.emptyRenameEvents
    );
  });

  it("Renames via a regex with no named groups", async () => {
    await setConfigRunMapTest(
      fixtures.regexNonNamedFullMatchRules,
      fixtures.regexNonNamedFullMatchEvents
    );
  });

  it("Substitutes every named group in a regex rename", async () => {
    await setConfigRunMapTest(
      fixtures.regexMultiGroupRenameRules,
      fixtures.regexMultiGroupRenameEvents
    );
  });

  it("Does not fall back to event match when a regex rule does not match", async () => {
    await setConfigRunMapTest(
      fixtures.regexEventNoFallbackRules,
      fixtures.regexEventNoFallbackEvents
    );
  });
});