local array = require "util.array";

describe("util.array", function ()

	describe("creation", function ()

		describe("new", function ()

			it("works", function ()

				local a = array.new({"a", "b", "c"});

				assert.same({"a", "b", "c"}, a);

			end);

		end);

		describe("from table", function ()

			it("works", function ()

				local a = array({"a", "b", "c"});

				assert.same({"a", "b", "c"}, a);

			end);

		end);

		describe("from iterator", function ()

			it("works", function ()

				-- collects the first value, ie the keys

				local a = array(ipairs({true, true, true}));

				assert.same({1, 2, 3}, a);

			end);

		end);

		describe("collect", function ()

			it("works", function ()

				-- collects the first value, ie the keys

				local a = array.collect(ipairs({true, true, true}));

				assert.same({1, 2, 3}, a);

			end);

		end);

	end);

	describe("metatable", function ()

		describe("operator", function ()

			describe("addition", function ()

				it("works", function ()

					local a = array({ "a", "b" });

					local b = array({ "c", "d" });

					assert.same({"a", "b", "c", "d"}, a + b);

				end);

			end);

			describe("equality", function ()

				it("works", function ()

					local a1 = array({ "a", "b" });

					local a2 = array({ "a", "b" });

					local b = array({ "c", "d" });

					assert.truthy(a1 == a2);

					assert.falsy(a1 == b);

					assert.falsy(a1 == { "a", "b" }, "Behavior of metatables changed in Lua 5.3");

				end);

			end);

			describe("division", function ()

				it("works", function ()

					local a = array({ "a", "b", "c" });

					local b = a / function (i) if i ~= "b" then return i .. "x" end end;

					assert.same({ "ax", "cx" }, b);

				end);

			end);

		end);

	end);

	describe("methods", function ()

		describe("map", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				local b = a:map(string.upper);

				assert.same({ "A", "B", "C" }, b);

			end);

		end);

		describe("filter", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				a:filter(function (i) return i ~= "b" end);

				assert.same({ "a", "c" }, a);

			end);

		end);

		describe("sort", function ()

			it("works", function ()

				local a = array({ 5, 4, 3, 1, 2, });

				a:sort();

				assert.same({ 1, 2, 3, 4, 5, }, a);

			end);

		end);

		describe("unique", function ()

			it("works", function ()

				local a = array({ "a", "b", "c", "c", "a", "b" });

				a:unique();

				assert.same({ "a", "b", "c" }, a);

			end);

		end);

		describe("pluck", function ()

			it("works", function ()

				local a = array({ { a = 1, b = -1 }, { a = 2, b = -2 }, });

				a:pluck("a");

				assert.same({ 1, 2 }, a);

			end);

		end);

		describe("reverse", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				a:reverse();

				assert.same({ "c", "b", "a" }, a);

			end);

		end);

		-- TODO :shuffle

		describe("append", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				a:append(array({ "d", "e", }));

				assert.same({ "a", "b", "c", "d", "e" }, a);

			end);

		end);

		describe("push", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				a:push("d"):push("e");

				assert.same({ "a", "b", "c", "d", "e" }, a);

			end);

		end);

		describe("pop", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				assert.equal("c", a:pop());

				assert.same({ "a", "b", }, a);

			end);

		end);

		describe("concat", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				assert.equal("a,b,c", a:concat(","));

			end);

		end);

		describe("length", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				assert.equal(3, a:length());

			end);

		end);

		describe("slice", function ()

			it("works", function ()

				local a = array({ "a", "b", "c" });

				assert.equal(array.slice(a, 1, 2), array{ "a", "b" });

				assert.equal(array.slice(a, 1, 3), array{ "a", "b", "c" });

				assert.equal(array.slice(a, 2, 3), array{ "b", "c" });

				assert.equal(array.slice(a, 2), array{ "b", "c" });

				assert.equal(array.slice(a, -4), array{ "a", "b", "c" });

				assert.equal(array.slice(a, -3), array{ "a", "b", "c" });

				assert.equal(array.slice(a, -2), array{ "b", "c" });

				assert.equal(array.slice(a, -1), array{ "c" });

			end);

			it("can mutate", function ()

				local a = array({ "a", "b", "c" });

				assert.equal(a:slice(-1), array{"c"});

				assert.equal(a, array{"c"});

			end);

		end);

	end);

	-- TODO The various array.foo(array ina, array outa) functions

end);