import type {
  AdvertisedEndpoint,
  AdvertisedEndpointHostedHttpsCompatibility,
  AdvertisedEndpointProvider,
  AdvertisedEndpointReachability,
  AdvertisedEndpointSource,
  AdvertisedEndpointStatus,
} from "@t3tools/contracts";
import * as Schema from "effect/Schema";

import { getUrlDiagnostics } from "./urlDiagnostics.ts";

const AdvertisedEndpointInputDiagnosticFields = {
  inputLength: Schema.Number,
  inputProtocol: Schema.optional(Schema.String),
  inputHostname: Schema.optional(Schema.String),
};

function advertisedEndpointInputDiagnostics(input: string) {
  const diagnostics = getUrlDiagnostics(input);
  return {
    inputLength: diagnostics.inputLength,
    ...(diagnostics.protocol === undefined ? {} : { inputProtocol: diagnostics.protocol }),
    ...(diagnostics.hostname === undefined ? {} : { inputHostname: diagnostics.hostname }),
  };
}

export class AdvertisedEndpointUrlParseError extends Schema.TaggedErrorClass<AdvertisedEndpointUrlParseError>()(
  "AdvertisedEndpointUrlParseError",
  {
    ...AdvertisedEndpointInputDiagnosticFields,
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return "Invalid advertised endpoint URL.";
  }
}

export class AdvertisedEndpointProtocolError extends Schema.TaggedErrorClass<AdvertisedEndpointProtocolError>()(
  "AdvertisedEndpointProtocolError",
  {
    ...AdvertisedEndpointInputDiagnosticFields,
    protocol: Schema.String,
  },
) {
  override get message(): string {
    return `Endpoint must use HTTP or HTTPS. Received ${this.protocol}`;
  }
}

export interface CreateAdvertisedEndpointInput {
  readonly id: string;
  readonly label: string;
  readonly provider: AdvertisedEndpointProvider;
  readonly httpBaseUrl: string;
  readonly reachability: AdvertisedEndpointReachability;
  readonly hostedHttpsCompatibility?: AdvertisedEndpointHostedHttpsCompatibility;
  readonly desktopCompatibility?: "compatible" | "unknown";
  readonly source: AdvertisedEndpointSource;
  readonly status?: AdvertisedEndpointStatus;
  readonly isDefault?: boolean;
  readonly description?: string;
}

export function normalizeHttpBaseUrl(rawValue: string): string {
  let url: URL;
  try {
    url = new URL(rawValue);
  } catch (cause) {
    throw new AdvertisedEndpointUrlParseError({
      ...advertisedEndpointInputDiagnostics(rawValue),
      cause,
    });
  }
  if (url.protocol === "ws:") {
    url.protocol = "http:";
  } else if (url.protocol === "wss:") {
    url.protocol = "https:";
  }

  if (url.protocol !== "http:" && url.protocol !== "https:") {
    throw new AdvertisedEndpointProtocolError({
      ...advertisedEndpointInputDiagnostics(rawValue),
      protocol: url.protocol,
    });
  }

  url.pathname = "/";
  url.search = "";
  url.hash = "";
  return url.toString();
}

export function deriveWsBaseUrl(httpBaseUrl: string): string {
  const url = new URL(normalizeHttpBaseUrl(httpBaseUrl));
  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
  return url.toString();
}

export function classifyHostedHttpsCompatibility(
  httpBaseUrl: string,
  fallback: AdvertisedEndpointHostedHttpsCompatibility = "unknown",
): AdvertisedEndpointHostedHttpsCompatibility {
  const url = new URL(normalizeHttpBaseUrl(httpBaseUrl));
  if (url.protocol === "http:") {
    return "mixed-content-blocked";
  }
  return fallback === "mixed-content-blocked" ? "unknown" : fallback;
}

export function createAdvertisedEndpoint(input: CreateAdvertisedEndpointInput): AdvertisedEndpoint {
  const httpBaseUrl = normalizeHttpBaseUrl(input.httpBaseUrl);
  return {
    id: input.id,
    label: input.label,
    provider: input.provider,
    httpBaseUrl,
    wsBaseUrl: deriveWsBaseUrl(httpBaseUrl),
    reachability: input.reachability,
    compatibility: {
      hostedHttpsApp:
        input.hostedHttpsCompatibility ?? classifyHostedHttpsCompatibility(httpBaseUrl),
      desktopApp: input.desktopCompatibility ?? "compatible",
    },
    source: input.source,
    status: input.status ?? "available",
    ...(input.isDefault === undefined ? {} : { isDefault: input.isDefault }),
    ...(input.description === undefined ? {} : { description: input.description }),
  };
}