"use strict";
// Directives: a message on <root>/<endpointId>/alexaDirective reaches the device's "Event" or "ReportState" listener,
// and what the device answers is published on <root>/<endpointId>/alexaResponce.
const { test } = require("node:test");
const assert = require("node:assert/strict");
const {
  Alex2MQTT, AlexaErrorType, AlexaInterfaceType, DisplayCategory, PowerController, EndpointHealth, TemperatureSensorScale,
} = require("alex2node");
const { setup, directive, until, UUID_V4 } = require("./helpers/harness.js");

// A light that answers every directive with its new power state and ReportState with "off at 0 %".
function diningRoomLight(bridge) {
  const lamp = bridge.registerDevice("Dining Room Light", "5020AA", DisplayCategory.LIGHT);
  lamp.addCapability(AlexaInterfaceType.POWER_CONTROLLER, { proactivelyReported: true });
  lamp.addCapability(AlexaInterfaceType.BRIGHTNESS_CONTROLLER);
  lamp.on("Event", (request) => {
    lamp.getStatusMessage(request.header.correlationToken, true)
      .addHealthProp(EndpointHealth.OK)
      .addPowerControllerProp(request.header.name === "TurnOn" ? PowerController.ON : PowerController.OFF)
      .addBrightnessControllerProp(100)
      .send(false);
  });
  lamp.on("ReportState", (request) => {
    lamp.getStatusMessage(request.header.correlationToken)
      .addPowerControllerProp(PowerController.OFF)
      .addBrightnessControllerProp(0)
      .send(false);
  });
  return lamp;
}

// A light that is not there: every directive is answered with ENDPOINT_UNREACHABLE.
function unpluggedLight(bridge) {
  const lamp = bridge.registerDevice("Garage Light", "5020AB", DisplayCategory.LIGHT);
  lamp.addCapability(AlexaInterfaceType.POWER_CONTROLLER);
  lamp.on("Event", (request) => {
    const error = lamp.getErrorMessage(request.header.correlationToken);
    error.setErrorMessage(AlexaErrorType.ENDPOINT_UNREACHABLE, "the light is unplugged");
    error.send();
  });
  return lamp;
}

// A scene that answers Activate and Deactivate with the matching event.
function eveningScene(bridge) {
  const scene = bridge.registerDevice("Evening", "scene-1", DisplayCategory.SCENE_TRIGGER);
  scene.addCapability(AlexaInterfaceType.SCENE_CONTROLLER);
  scene.on("Event", (request) => {
    scene.sendSceneResponse(request.header.correlationToken, request.header.name === "Activate");
  });
  return scene;
}

test("a directive reaches the \"Event\" listener and is answered with a Response carrying its correlationToken", async () => {
  const { alexa, bridge } = await setup(Alex2MQTT, "root");
  const dispatched = [];
  bridge.on("directive", (info) => dispatched.push(info));
  diningRoomLight(bridge);

  alexa.send("root", directive("Alexa.PowerController", "TurnOn", "5020AA", "ct1"));
  await until(() => alexa.on("root/5020AA/alexaResponce").length === 1, 3000, "directive response");
  const [response] = alexa.on("root/5020AA/alexaResponce");
  assert.equal(response.event.header.name, "Response");
  assert.equal(response.event.header.correlationToken, "ct1");
  assert.match(response.event.header.messageId, UUID_V4);
  assert.equal(response.context.properties.find((p) => p.name === "powerState").value, "ON");
  assert.deepEqual(dispatched, [{ endpointId: "5020AA", namespace: "Alexa.PowerController", name: "TurnOn" }]);
});

test("ReportState reaches the \"ReportState\" listener and is answered with a StateReport", async () => {
  const { alexa, bridge } = await setup(Alex2MQTT, "root");
  diningRoomLight(bridge);

  alexa.send("root", directive("Alexa", "ReportState", "5020AA", "ct2"));
  await until(() => alexa.on("root/5020AA/alexaResponce").length === 1, 3000, "state report");
  const [report] = alexa.on("root/5020AA/alexaResponce");
  assert.equal(report.event.header.name, "StateReport");
  assert.equal(report.event.header.correlationToken, "ct2");
  assert.match(report.event.header.messageId, UUID_V4);
  assert.deepEqual(report.context.properties.map((p) => [p.name, p.value]), [["powerState", "OFF"], ["brightness", 0]]);
});

test("getErrorMessage: the directive is answered with an ErrorResponse, the error type and message as its payload", async () => {
  const { alexa, bridge } = await setup(Alex2MQTT, "root");
  unpluggedLight(bridge);

  alexa.send("root", directive("Alexa.PowerController", "TurnOn", "5020AB", "ct4"));
  await until(() => alexa.on("root/5020AB/alexaResponce").length === 1, 3000, "error response");
  const [answer] = alexa.on("root/5020AB/alexaResponce");
  const { messageId, ...header } = answer.event.header;
  assert.match(messageId, UUID_V4);
  // The event alone, without a context (Alexa.ErrorResponse, "Synchronous error response")
  assert.deepEqual({ ...answer, event: { ...answer.event, header } }, {
    event: {
      header: { namespace: "Alexa", name: "ErrorResponse", correlationToken: "ct4", payloadVersion: "3" },
      endpoint: { endpointId: "5020AB" },
      payload: { type: "ENDPOINT_UNREACHABLE", message: "the light is unplugged" },
    },
  });
});

test("SceneController: Activate is answered with ActivationStarted", async () => {
  const { alexa, bridge } = await setup(Alex2MQTT, "root");
  eveningScene(bridge);

  alexa.send("root", directive("Alexa.SceneController", "Activate", "scene-1", "ct3"));
  await until(() => alexa.on("root/scene-1/alexaResponce").length === 1, 3000, "scene response");
  const [started] = alexa.on("root/scene-1/alexaResponce");
  assert.equal(started.event.header.namespace, "Alexa.SceneController");
  assert.equal(started.event.header.name, "ActivationStarted");
  assert.match(started.event.header.messageId, UUID_V4);
  assert.equal(started.event.payload.cause.type, "VOICE_INTERACTION");
  assert.ok(started.event.payload.timestamp);
});

test("no two answers share a messageId: Response, ErrorResponse and the scene events each get a new one", async () => {
  const { alexa, bridge } = await setup(Alex2MQTT, "root");
  diningRoomLight(bridge);
  unpluggedLight(bridge);
  eveningScene(bridge);
  const answers = () => alexa.got.filter((m) => m.topic.endsWith("/alexaResponce")).map((m) => m.payload.event.header);

  for (const token of ["first", "second"]) {
    alexa.send("root", directive("Alexa.PowerController", "TurnOn", "5020AA", token));
    alexa.send("root", directive("Alexa.PowerController", "TurnOn", "5020AB", token));
    alexa.send("root", directive("Alexa.SceneController", "Activate", "scene-1", token));
  }
  await until(() => answers().length === 6, 3000, "six answers");
  assert.deepEqual(
    answers().map((header) => header.name).sort(),
    ["ActivationStarted", "ActivationStarted", "ErrorResponse", "ErrorResponse", "Response", "Response"]
  );
  const ids = answers().map((header) => header.messageId);
  for (const id of ids) assert.match(id, UUID_V4);
  assert.equal(new Set(ids).size, 6, `a messageId is used twice: ${ids.join(" ")}`);
});

test("the temperature helpers convert Fahrenheit to Celsius (as 1.4.0 did)", async () => {
  const { bridge } = await setup(Alex2MQTT, "root");
  const lamp = diningRoomLight(bridge);
  const message = lamp.getStatusMessage("x")
    .addTemperatureSensorProp(TemperatureSensorScale.FAHRENHEIT, 68)
    .addThermostatControllerProp("lowerSetpoint", TemperatureSensorScale.FAHRENHEIT, 68)
    .toJSON();
  const toOneDecimal = (n) => Math.round(n * 10) / 10;
  for (const name of ["temperature", "lowerSetpoint"]) {
    const { value } = message.context.properties.find((p) => p.name === name);
    assert.equal(toOneDecimal(value.value), 20, name);
    assert.equal(value.scale, "CELSIUS", name);
  }
});