import { Link, Service } from "@kumori/aurora-interfaces";


interface HandleLinkEventParams {
  eventData: any;
  servicesMap: Map<string, Service>;
}

interface HandleLinkEventResult {
  linkId: string;
  clientToServerLink: Link;
  serverToClientLink: Link;
  linkServiceServer: string;
  linkServiceClient: string;
  updatedServerService: Service | null;
  updatedClientService: Service | null;
  serverServiceFound: boolean;
  clientServiceFound: boolean;
}
/**
 * Handles the "link" event from WebSocket messages
 * Creates bidirectional links between services
 */
export const handleLinkEvent = ({
  eventData,
  servicesMap,
}: HandleLinkEventParams): HandleLinkEventResult => {
  const linkId = eventData.id.name;
  const clientService = eventData.spec.client_service;
  const clientChannel = eventData.spec.client_channel;
  const serverService = eventData.spec.server_service;
  const serverChannel = eventData.spec.server_channel;
  const linkServiceServer = `${eventData.spec.server_tenant}/${serverService}`;
  const linkServiceClient = `${eventData.spec.client_tenant}/${clientService}`;
  const isBeeingDeleted : boolean = !!eventData.meta.deleted;
  const clientToServerLink: Link = {
    name: linkId,
    origin: clientService,
    target: serverService,
    originChannel: clientChannel,
    targetChannel: serverChannel,
    client: clientChannel,
    server: serverChannel,
    delete: isBeeingDeleted,
  };

  const serverToClientLink: Link = {
    name: linkId,
    origin: clientService,
    target: serverService,
    originChannel: clientChannel,
    targetChannel: serverChannel,
    client: clientChannel,
    server: serverChannel,
    delete: isBeeingDeleted,
  };
  let updatedServerService: Service | null = null;
  let serverServiceFound = false;

  const serverServiceObj = servicesMap.get(linkServiceServer);
  if (serverServiceObj) {
    serverServiceFound = true;
    const existingLinkIndex = serverServiceObj.links.findIndex(
      (link) =>
        link.name === clientToServerLink.name &&
        link.origin === clientToServerLink.origin &&
        link.target === clientToServerLink.target
    );

    if (existingLinkIndex !== -1) {
      serverServiceObj.links[existingLinkIndex] = clientToServerLink;
    } else {
      serverServiceObj.links.push(clientToServerLink);
    }
    updatedServerService = serverServiceObj;
  } else {
    console.warn(
      `Client service ${linkServiceServer} not found when processing link event`
    );
  }
  let updatedClientService: Service | null = null;
  let clientServiceFound = false;

  const clientServiceObj = servicesMap.get(linkServiceClient);
  if (clientServiceObj) {
    clientServiceFound = true;
    const existingLinkIndex = clientServiceObj.links.findIndex(
      (link) =>
        link.name === serverToClientLink.name &&
        link.origin === serverToClientLink.origin &&
        link.target === serverToClientLink.target
    );

    if (existingLinkIndex !== -1) {
      clientServiceObj.links[existingLinkIndex] = serverToClientLink;
    } else {
      clientServiceObj.links.push(serverToClientLink);
    }
    updatedClientService = clientServiceObj;
  } else {
    console.warn(
      `Server service ${linkServiceClient} not found when processing link event`
    );
  }

  return {
    linkId,
    clientToServerLink,
    serverToClientLink,
    linkServiceServer,
    linkServiceClient,
    updatedServerService,
    updatedClientService,
    serverServiceFound,
    clientServiceFound,
  };
};