import express, { Request, Response } from "express";
import { container } from "tsyringe";
import { domainEventEmitter } from "../config/eventEmitter";
import {
  TtnMessageReceivedEvent,
  TtnMessageReceivedEventName,
} from "../event/ttnMessageReceivedEvent";
import { validateData } from "../middleware/validationMiddleware";
import { TtnMessage } from "../models/ttnMessage";
import { LpTtnEndDeviceUplinksService } from "../services/lpTtnEndDeviceUplinksService";
import { TtnGatewayReceptionService } from "../services/ttnGatewayReceptionService";
import { WifiScanService } from "../services/wifiScanService";
import { ttnMessageValidator } from "../validation/ttn/ttnMessageValidation";

const lpTtnEndDeviceUplinksService = container.resolve(
  LpTtnEndDeviceUplinksService
);
const ttnGatewayReceptionService = container.resolve(
  TtnGatewayReceptionService
);
const wifiScanService = container.resolve(WifiScanService);

const router = express.Router();

router.post(
  "/webhook",
  validateData(ttnMessageValidator),
  async (req: Request, res: Response) => {
    try {
      const message = req.body as TtnMessage;
      const { lp_ttn_end_device_uplinks_id } =
        await lpTtnEndDeviceUplinksService.createUplink({
          device_id: message.end_device_ids.device_id,
          application_ids:
            message.end_device_ids.application_ids.application_id,
          dev_eui: message.end_device_ids.dev_eui,
          join_eui: message.end_device_ids.join_eui,
          dev_addr: message.end_device_ids.dev_addr,
          received_at_utc: new Date(message.received_at),
          battery: message.uplink_message.decoded_payload?.messages[0].find(
            (e) => e.type === "Battery"
          )?.measurementValue,
          latitude: 0 /*
        message.uplink_message.decoded_payload.messages[0].find(
          (e) => e.type === "Latitude"
        )?.measurementValue
        */,
          longitude: 0,
          /*
        message.uplink_message.decoded_payload.messages[0].find(
          (e) => e.type === "Longitude"
        )?.measurementValue
        */
        });

      const wifiScans =
        message.uplink_message.decoded_payload?.messages[0]
          .find((e) => e.type === "Wi-Fi Scan")
          ?.measurementValue?.map((w) => ({
            lp_ttn_end_device_uplinks_id,
            mac: w.mac,
            rssi: w.rssi,
          })) ?? [];

      const ttnGatewayReceptions = message.uplink_message.rx_metadata.map(
        (g) => ({
          lp_ttn_end_device_uplinks_id,
          gateway_id: g.gateway_ids.gateway_id,
          eui: g.gateway_ids.eui,
          rssi: g.rssi,
          latitude: g.location.latitude,
          longitude: g.location.longitude,
          altitude: g.location.altitude,
        })
      );

      const event: TtnMessageReceivedEvent = {
        lp_ttn_end_device_uplinks_id,
        wifis: wifiScans.map((w) => ({ mac: w.mac, rssi: w.rssi })),
        ttnGateways: ttnGatewayReceptions.map((g) => ({
          rssi: g.rssi,
          altitude: g.altitude,
          latitude: g.latitude,
          longitude: g.longitude,
        })),
      };

      domainEventEmitter.emit(TtnMessageReceivedEventName, event);

      await Promise.all([
        wifiScanService.createWifiScans(wifiScans),
        ttnGatewayReceptionService.createGatewayReceptions(
          ttnGatewayReceptions
        ),
      ]);

      res.status(200);
    } catch (error) {
      console.log(error);
      res.status(500).json({ error: "Error creating uplink" });
    }
  }
);

export default router;