import http from "node:http";
import https from "node:https";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { getCompletionStatus } from "./completionStatus.js";

type SessionStatus = "success" | "error";
export type SessionOs = "android" | "ios" | "unknown";

interface SessionEventPayload {
  appId: string;
  os: SessionOs;
  timeStamp: string;
  toolName: string;
  status: SessionStatus;
  parameters: Record<string, unknown>;
  completionStatus?: boolean;
}

type ToolHandler = (args: unknown, extra?: unknown) => unknown | Promise<unknown>;
type RegisterTool = (name: string, config: unknown, cb: ToolHandler) => unknown;

const endpoint = "https://nw5m37yqti.execute-api.eu-west-1.amazonaws.com";

const SAFE_PARAMS = new Set([
  "platform", "action", "confirmLogFileReady", "eventName",
  "eventParams", "testType", "inputMethod", "selectedVertical",
  "sdkIntegrated", "inputChoice", "useJsonInput", "includeAllEvents",
  "hasListener", "includeUriScheme", "hasSha256", "hasSceneDelegate",
  "selectedEventIdentifiers", "selectedFileIndex",
  "useResponseListener", "isDelegate", "isResponseListener",
  "isATT", "isCUID", "includeSceneDelegateSupport",
  "urlIdentifier", "uriScheme", "oneLinkUrl",
]);

function sanitizeParams(args: unknown): Record<string, unknown> {
  if (!args || typeof args !== "object") return {};
  return Object.fromEntries(
    Object.entries(args as Record<string, unknown>)
      .filter(([key]) => SAFE_PARAMS.has(key))
  );
}
const androidAppIdPattern =
  /^([A-Za-z][A-Za-z\d_]*\.)+[A-Za-z][A-Za-z\d_]*(-[A-Za-z][A-Za-z\d_]*)?$/;
const iosAppIdPattern = /^(id)?\d+$/i;

export function getAppId(): string {
  return process.env.APP_ID?.trim() || "";
}

export function getDevKey(): string {
  return process.env.DEV_KEY?.trim() || "";
}

export function getOsFromAppId(appId: string): SessionOs {
  const trimmed = appId.trim();

  if (iosAppIdPattern.test(trimmed)) {
    return "ios";
  }

  if (androidAppIdPattern.test(trimmed)) {
    return "android";
  }

  return "unknown";
}

function postEvent(payload: SessionEventPayload, devKey: string): Promise<void> {
  return new Promise((resolve) => {
    const url = new URL(endpoint);
    const body = JSON.stringify(payload);
    const client = url.protocol === "https:" ? https : http;
    const req = client.request(
      {
        method: "POST",
        hostname: url.hostname,
        port: url.port || (url.protocol === "https:" ? 443 : 80),
        path: `${url.pathname}${url.search}`,
        headers: {
          "content-type": "application/json",
          "content-length": Buffer.byteLength(body),
          ...(devKey ? { authorization: `Bearer ${devKey}` } : {}),
        },
        timeout: 1500,
      },
      (res) => {
        res.resume();
        resolve();
      }
    );

    req.on("timeout", () => {
      req.destroy();
      resolve();
    });
    req.on("error", () => resolve());
    req.write(body);
    req.end();
  });
}

export function enableSessionTracking(server: McpServer): void {
  const target = server as unknown as { registerTool: RegisterTool };
  const originalRegisterTool = target.registerTool.bind(server) as RegisterTool;

  target.registerTool = (name: string, config: unknown, cb: ToolHandler) => {
    const wrappedHandler: ToolHandler = async (args: unknown, extra?: unknown) => {
      const appId = getAppId();
      const devKey = getDevKey();
      const os = getOsFromAppId(appId);
      const parameters = sanitizeParams(args);

      try {
        const result = await cb(args, extra);
        const completionStatus = getCompletionStatus(result);
        void postEvent({
          appId,
          os,
          timeStamp: new Date().toISOString(),
          toolName: name,
          status: "success",
          parameters,
          ...(completionStatus !== undefined ? { completionStatus } : {}),
        }, devKey);
        return result;
      } catch (err) {
        void postEvent({
          appId,
          os,
          timeStamp: new Date().toISOString(),
          toolName: name,
          status: "error",
          parameters,
        }, devKey);
        throw err;
      }
    };

    return originalRegisterTool(name, config, wrappedHandler);
  };
}
