import * as uut from "../index.js";

export function iotaTests({ describe, test, expect }) {
  describe("iota", () => {
    test("returns the right number of items", () => {
      for (let items = 0; items < 10; items++) {
        expect(() => uut.iota(items)).toHaveLength(items);
      }
    });
    test("returns the right number of items, independently of start", () => {
      for (let start = 0; start < 10; start++) {
        expect(() => uut.iota(5, start)).toHaveLength(5);
      }
      expect(() => uut.iota(5, 2.3)).toHaveLength(5);
    });
    test("returns the right start, if count > 0", () => {
      expect(() => uut.iota(0, 5)).toEqual([]);
      for (let items = 1; items < 10; items++) {
        expect(({ items }) => uut.iota(items, 5), { items }).toHaveProperty(
          "0",
          5
        );
        expect(({ items }) => uut.iota(items, -5), { items }).toHaveProperty(
          "0",
          -5
        );
        expect(({ items }) => uut.iota(items, 2.5), { items }).toHaveProperty(
          "0",
          2.5
        );
        expect(({ items }) => uut.iota(items, NaN), { items }).toHaveProperty(
          "0",
          NaN
        );
        expect(({ items }) => uut.iota(items, Infinity), {
          items,
        }).toHaveProperty("0", Infinity);
        expect(({ items }) => uut.iota(items, -Infinity), {
          items,
        }).toHaveProperty("0", -Infinity);
      }
    });
  });
}

export function overTests({ describe, test, expect }) {
  describe("over", () => {
    test("applies transform to each element", () => {
      expect(() => uut.over((v) => v + 1)([1, 2, 3])).toEqual([2, 3, 4]);
    });
    test("preserves length", () => {
      for (let items = 0; items < 10; items++) {
        const inp = uut.iota(items);
        expect(() => uut.over((v) => v)(inp)).toHaveLength(items);
      }
    });
  });
}

export function juxtTests({ describe, test, expect }) {
  describe("juxt", () => {
    test("works", () => {
      expect(() =>
        uut.juxt(
          (v) => v + 1,
          (v) => v * 2,
          (v) => v / 2,
          (v) => v - 2
        )(6)
      ).toEqual([7, 12, 3, 4]);
    });
    test("runs each transform", () => {
      for (let items = 1; items < 10; items++) {
        const inp = uut.iota(items).map(() => (v) => v);
        expect(() => uut.juxt(...inp)({})).toHaveLength(items);
      }
    });
  });
}

export function onTests({ describe, test, expect }) {
  describe("on", () => {
    test("works", () => {
      expect(() =>
        uut.on(
          (v) => v + 1,
          ({ a }) => a
        )({ a: 2 })
      ).toEqual(3);
    });
  });
}

export function applyingTests({ describe, test, expect }) {
  describe("applying", () => {
    test("works", () => {
      expect(() =>
        uut.applying(
          (...args) => args.reduce((a, b) => a + b, 0),
          2,
          3
        )([4, 5, 6])
      ).toEqual(2 + 3 + 4 + 5 + 6);
    });
  });
}

export function filterTests({ describe, test, expect }) {
  describe("filter", () => {
    test("works", () => {
      expect(() => uut.filter((a, b) => a < b, 6)([4, 5, 6])).toEqual([4, 5]);
    });
  });
}

export function includeTests({ describe, test, expect }) {
  describe("include", () => {
    test("works", () => {
      expect(() => uut.include((a) => a < 6)([4, 5, 6])).toEqual([4, 5]);
    });
  });
}

export function excludeTests({ describe, test, expect }) {
  describe("exclude", () => {
    test("works", () => {
      expect(() => uut.exclude((a, b) => a < 6)([4, 5, 6])).toEqual([6]);
    });
  });
}

export function zip_withTests({ describe, test, expect }) {
  describe("zip_with", () => {
    test("works", () => {
      expect(() =>
        uut.zip_with((a, b) => a < b)([
          [4, 5, 6],
          [6, 5, 4],
        ])
      ).toEqual([true, false, false]);
      expect(() =>
        uut.zip_with((a, b, c) => a + b + c)([
          [4, 5, 6],
          [6, 5, 4],
          [0, 0, 0],
        ])
      ).toEqual([10, 10, 10]);
    });
  });
}

export function elementTests({ describe, test, expect }) {
  describe("element", () => {
    test("works", () => {
      expect(() => uut.element(0)([1])).toEqual(1);
    });
  });
}

export function keyTests({ describe, test, expect }) {
  describe("key", () => {
    test("works", () => {
      expect(() => uut.key(0)([1])).toEqual(1);
      expect(() => uut.key("a")({ a: 1 })).toEqual(1);
    });
  });
}

export function eqTests({ describe, test, expect }) {
  describe("eq", () => {
    test("works", () => {
      expect(() => uut.eq(0)(0)).toBeTruthy();
      expect(() => uut.eq(0, (a, b) => a + 1 === b - 1)(2)).toBeTruthy();
    });
  });
}

export function applicable_whenTests({ describe, test, expect }) {
  describe("applicable_when", () => {
    test("works", () => {
      expect(() =>
        uut.applicable_when(
          () => true,
          (v) => v + 1
        )(0)
      ).toEqual(1);
      expect(() =>
        uut.applicable_when(
          () => false,
          (v) => v + 1
        )(0)
      ).toEqual(0);
    });
  });
}

export function matches_regexTests({ describe, test, expect }) {
  describe("matches_regex", () => {
    test("works", () => {
      expect(() => uut.matches_regex(/^a/)("a")).toBeTruthy();
      expect(() => uut.matches_regex(/^a/)("b")).toBeFalsy();
      expect(() => uut.matches_regex(/a/)("ba")).toBeTruthy();
      expect(() =>
        uut.matches_regex({
          test() {
            return true;
          },
        })()
      ).toEqual(true);
      expect(() =>
        uut.matches_regex({
          test() {
            return false;
          },
        })()
      ).toEqual(false);
    });
  });
}

export function complementTests({ describe, test, expect }) {
  describe("complement", () => {
    test("works", () => {
      expect(() => uut.complement(() => true)()).toEqual(false);
      expect(() => uut.complement(() => false)()).toEqual(true);
      expect(() => uut.complement((a, b) => a < b)(1, 2)).toEqual(false);
      expect(() => uut.complement((a, b) => a < b)(1, 1)).toEqual(true);
      expect(() => uut.complement((a, b) => a < b)(2, 1)).toEqual(true);
    });
  });
}

export function pickTests({ describe, test, expect }) {
  describe("pick", () => {
    test("works", () => {
      expect(() => uut.pick({ a: 1, b: 2, c: 3 })(["a", "c"])).toEqual([1, 3]);
    });
  });
}

/*
(funcall (on (alexandria:compose
              (over (transform-tail (over (slice 1))))
              (compress-runs :collector 'combine-matching-lists))
             (alexandria:compose
              (over (juxt (element 0)
                          'identity))
              (sorted 'char<
                      :key (element 0))))
         '("January" "February" "March" "April"
           "May" "June" "July" "August"
           "September" "October" "November" "December"))
*/

function compress_runsTest({ describe, test, expect, when }) {
  describe("compress_runs", () => {
    test("works", () => {
      when(uut.compress_runs)
        .isCalledWith([], [[1, 1, 2, 3, 3, 4, 5, 5]])
        .expect.toEqual([1, 2, 3, 4, 5]);

      when(uut.compress_runs)
        .isCalledWith([], [[1, 2, 3, 4, 5]])
        .expect.toEqual([1, 2, 3, 4, 5]);

      when(uut.compress_runs).isCalledWith([], [[]]).expect.toEqual([]);
    });
  });
}

function composedTests({ describe, test, expect }) {
  describe("compose", () => {
    test("sample", () => {
      expect(() =>
        uut.compose(
          (v) => v + 1,
          (v) => v * 2,
          (v) => v + 1
        )(4)
      ).toEqual(11);

      (({
        combine_matching_lists,
        compose,
        compress_runs,
        element,
        juxt,
        on,
        over,
        slice,
        sorted,
        transform_tail,
      }) => {
        expect(() =>
          on(
            compose(
              over(transform_tail(over(slice(1)))),
              compress_runs({ collector: combine_matching_lists })
            ),
            compose(
              over(juxt(element(0), (x) => x)),
              sorted((a, b) => a < b, element(0))
            )
          )([
            "January",
            "February",
            "March",
            "April",
            "May",
            "June",
            "July",
            "August",
            "September",
            "October",
            "November",
            "December",
          ])
        ).toEqual([
          ["A", "pril", "ugust"],
          ["D", "ecember"],
          ["F", "ebruary"],
          ["J", "anuary", "une", "uly"],
          ["M", "arch", "ay"],
          ["N", "ovember"],
          ["O", "ctober"],
          ["S", "eptember"],
        ]);
      })(uut);
    });
  });
}

/**
 * @param {{ expect: any; test: any; describe: any; when: any; }} context
 */
export function tests(context) {
  [
    applicable_whenTests,
    applyingTests,
    complementTests,
    compress_runsTest,
    elementTests,
    eqTests,
    excludeTests,
    filterTests,
    filterTests,
    includeTests,
    iotaTests,
    juxtTests,
    keyTests,
    matches_regexTests,
    onTests,
    overTests,
    pickTests,
    zip_withTests,

    composedTests,
  ].forEach((test) => test(context));
}