import { createEmbed, getClickId, init, reset } from "./index";
import type { RefportTrackingOptions, RefportTrackingResult } from "./types";

interface RefportAutoGlobal {
  createEmbed: typeof createEmbed;
  getClickId: typeof getClickId;
  init: typeof init;
  reset: typeof reset;
  result: RefportTrackingResult;
}

declare global {
  interface Window {
    Refport?: RefportAutoGlobal;
    _refport?: RefportAutoGlobal;
  }
}

function parseBoolean(value: string | undefined): boolean | undefined {
  if (value === undefined) {
    return undefined;
  }

  if (value === "true") {
    return true;
  }

  if (value === "false") {
    return false;
  }

  return undefined;
}

function parseNumber(value: string | undefined): number | undefined {
  if (value === undefined) {
    return undefined;
  }

  const parsed = Number(value);
  return Number.isFinite(parsed) ? parsed : undefined;
}

function parseCookieOptions(
  value: string | undefined
): Partial<RefportTrackingOptions> {
  if (value === undefined) {
    return {};
  }

  try {
    const parsed: unknown = JSON.parse(value);
    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
      return {};
    }

    const cookieOptions = parsed as Record<string, unknown>;
    const options: Partial<RefportTrackingOptions> = {};

    if (typeof cookieOptions.domain === "string") {
      options.domain = cookieOptions.domain;
    }
    if (typeof cookieOptions.path === "string") {
      options.path = cookieOptions.path;
    }
    if (typeof cookieOptions.maxAge === "number") {
      options.maxAge = cookieOptions.maxAge;
    }
    if (typeof cookieOptions.expiresInDays === "number") {
      options.maxAge = cookieOptions.expiresInDays * 24 * 60 * 60;
    }
    if (
      cookieOptions.sameSite === "Strict" ||
      cookieOptions.sameSite === "Lax" ||
      cookieOptions.sameSite === "None"
    ) {
      options.sameSite = cookieOptions.sameSite;
    }
    if (typeof cookieOptions.secure === "boolean") {
      options.secure = cookieOptions.secure;
    }

    return options;
  } catch {
    return {};
  }
}

function firstAvailableQueryParam(params: string[]): string | undefined {
  const [fallback] = params;
  if (typeof window === "undefined") {
    return fallback;
  }

  const searchParams = new URLSearchParams(window.location.search);
  return params.find((param) => searchParams.has(param)) ?? fallback;
}

function parseQueryParam(dataset: DOMStringMap): string | undefined {
  if (dataset.queryParam) {
    return dataset.queryParam;
  }

  if (dataset.queryParams) {
    try {
      const parsed: unknown = JSON.parse(dataset.queryParams);
      if (Array.isArray(parsed)) {
        return firstAvailableQueryParam(
          parsed.filter(
            (param): param is string =>
              typeof param === "string" && param.length > 0
          )
        );
      }
    } catch {
      return firstAvailableQueryParam(
        dataset.queryParams
          .split(",")
          .map((param) => param.trim())
          .filter((param) => param.length > 0)
      );
    }
  }

  return dataset.paramName;
}

function optionsFromCurrentScript(): RefportTrackingOptions {
  if (typeof document === "undefined") {
    return {};
  }

  const script = document.currentScript;
  if (!(script instanceof HTMLScriptElement)) {
    return {};
  }

  const { dataset } = script;
  const options: RefportTrackingOptions = parseCookieOptions(
    dataset.cookieOptions
  );
  const cleanUrl = parseBoolean(dataset.cleanUrl);
  const domain = dataset.cookieDomain ?? dataset.domain;
  const maxAge = parseNumber(dataset.maxAge);
  const paramName = parseQueryParam(dataset);
  const path = dataset.cookiePath ?? dataset.path;
  const secure = parseBoolean(dataset.secure);

  if (cleanUrl !== undefined) {
    options.cleanUrl = cleanUrl;
  }
  if (dataset.cookieName) {
    options.cookieName = dataset.cookieName;
  }
  if (domain) {
    options.domain = domain;
  }
  if (maxAge !== undefined) {
    options.maxAge = maxAge;
  }
  if (paramName) {
    options.paramName = paramName;
  }
  if (path) {
    options.path = path;
  }
  if (
    dataset.sameSite === "Strict" ||
    dataset.sameSite === "Lax" ||
    dataset.sameSite === "None"
  ) {
    options.sameSite = dataset.sameSite;
  }
  if (secure !== undefined) {
    options.secure = secure;
  }

  return options;
}

const options = optionsFromCurrentScript();
const result = init(options);
const refport = { createEmbed, getClickId, init, reset, result };

if (typeof window !== "undefined") {
  window.Refport = refport;
  window._refport = refport;
}

export { createEmbed, getClickId, init, reset, result };