import assert from "node:assert/strict";
import { Address } from "@clusterio/lib";

describe("lib/data/messages_core", function() {
	describe("class Address", function() {
		const controller = new Address(Address.controller, 0);
		const host1 = new Address(Address.host, 1);
		const host2 = new Address(Address.host, 2);
		const instance1 = new Address(Address.instance, 1);
		const instance2 = new Address(Address.instance, 2);
		const control1 = new Address(Address.control, 1);
		const control2 = new Address(Address.control, 2);
		const hostBr = new Address(Address.broadcast, Address.host);
		const instanceBr = new Address(Address.broadcast, Address.instance);
		const controlBr = new Address(Address.broadcast, Address.control);

		describe(".withoutRequestId()", () => {
			it("returns the same instance when requestId is undefined", () => {
				const address = new Address(1, 2);

				assert.strictEqual(address.withoutRequestId(), address);
			});

			it("returns a new instance when requestId is present", () => {
				const address = new Address(1, 2, 123);

				const result = address.withoutRequestId();

				assert.notStrictEqual(result, address);
				assert.deepEqual(result, new Address(1, 2));
			});

			it("does not modify the original address", () => {
				const address = new Address(1, 2, 123);

				address.withoutRequestId();

				assert.equal(address.type, 1);
				assert.equal(address.id, 2);
				assert.equal(address.requestId, 123);
			});
		});

		it("Should correctly resolve addressedTo", function() {
			assert(controller.addressedTo(controller));
			assert(!controller.addressedTo(host1));
			assert(!controller.addressedTo(instance1));
			assert(!controller.addressedTo(control1));
			assert(!controller.addressedTo(hostBr));
			assert(!controller.addressedTo(instanceBr));
			assert(!controller.addressedTo(controlBr));

			assert(!host1.addressedTo(controller));
			assert(host1.addressedTo(host1));
			assert(!host1.addressedTo(host2));
			assert(!host1.addressedTo(instance1));
			assert(!host1.addressedTo(control1));
			assert(!host1.addressedTo(hostBr));
			assert(!host1.addressedTo(instanceBr));
			assert(!host1.addressedTo(controlBr));

			assert(!instance1.addressedTo(controller));
			assert(!instance1.addressedTo(host1));
			assert(instance1.addressedTo(instance1));
			assert(!instance1.addressedTo(instance2));
			assert(!instance1.addressedTo(control1));
			assert(!instance1.addressedTo(hostBr));
			assert(!instance1.addressedTo(instanceBr));
			assert(!instance1.addressedTo(controlBr));

			assert(!control1.addressedTo(controller));
			assert(!control1.addressedTo(host1));
			assert(!control1.addressedTo(instance1));
			assert(control1.addressedTo(control1));
			assert(!control1.addressedTo(control2));
			assert(!control1.addressedTo(hostBr));
			assert(!control1.addressedTo(instanceBr));
			assert(!control1.addressedTo(controlBr));

			assert(!hostBr.addressedTo(controller));
			assert(hostBr.addressedTo(host1));
			assert(hostBr.addressedTo(host2));
			assert(!hostBr.addressedTo(instance1));
			assert(!hostBr.addressedTo(control1));
			assert(!hostBr.addressedTo(hostBr));
			assert(!hostBr.addressedTo(instanceBr));
			assert(!hostBr.addressedTo(controlBr));

			assert(!instanceBr.addressedTo(controller));
			assert(!instanceBr.addressedTo(host1));
			assert(instanceBr.addressedTo(instance1));
			assert(instanceBr.addressedTo(instance2));
			assert(!instanceBr.addressedTo(control1));
			assert(!instanceBr.addressedTo(hostBr));
			assert(!instanceBr.addressedTo(instanceBr));
			assert(!instanceBr.addressedTo(controlBr));

			assert(!controlBr.addressedTo(controller));
			assert(!controlBr.addressedTo(host1));
			assert(!controlBr.addressedTo(instance1));
			assert(controlBr.addressedTo(control1));
			assert(controlBr.addressedTo(control2));
			assert(!controlBr.addressedTo(hostBr));
			assert(!controlBr.addressedTo(instanceBr));
			assert(!controlBr.addressedTo(controlBr));
		});
	});
});