import {
  ProviderDriverKind,
  TrimmedNonEmptyString,
  type ServerProvider,
  type ServerProviderCompatibilityAdvisory,
} from "@t3tools/contracts";
import { satisfiesSemverRange } from "@t3tools/shared/semver";
import * as Cache from "effect/Cache";
import * as Context from "effect/Context";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Schema from "effect/Schema";
import { HttpClient, HttpClientRequest } from "effect/unstable/http";

import bundledCompatibilityDocumentJson from "../../../../provider-compatibility.v1.json" with { type: "json" };
import packageJson from "../../package.json" with { type: "json" };
import {
  makeTargetedProviderUpdateAction,
  type ProviderMaintenanceCapabilities,
} from "./providerMaintenance.ts";

const T3_CODE_VERSION = packageJson.version;
const REMOTE_COMPATIBILITY_CACHE_TTL = Duration.minutes(15);
const REMOTE_COMPATIBILITY_TIMEOUT = "2500 millis";
const REMOTE_COMPATIBILITY_CACHE_CAPACITY = 8;

export const DEFAULT_PROVIDER_COMPATIBILITY_MAP_URL =
  "https://t3.codes/provider-compatibility.v1.json";
export const GITHUB_PROVIDER_COMPATIBILITY_MAP_URL =
  "https://raw.githubusercontent.com/pingdotgg/t3code/main/provider-compatibility.v1.json";
export const DEFAULT_PROVIDER_COMPATIBILITY_MAP_URLS = [
  DEFAULT_PROVIDER_COMPATIBILITY_MAP_URL,
  GITHUB_PROVIDER_COMPATIBILITY_MAP_URL,
] as const;

const RemoteCompatibilityRange = Schema.Struct({
  status: Schema.Literals(["unknown", "supported", "graceful", "unsupported", "broken"]),
  range: TrimmedNonEmptyString,
  label: Schema.optional(TrimmedNonEmptyString),
});

const RemoteCompatibilityPolicy = Schema.Struct({
  t3CodeRange: TrimmedNonEmptyString,
  driver: TrimmedNonEmptyString,
  recommendedRange: Schema.NullOr(TrimmedNonEmptyString),
  recommendedVersion: Schema.optionalKey(Schema.NullOr(TrimmedNonEmptyString)),
  ranges: Schema.Array(RemoteCompatibilityRange),
});

const RemoteCompatibilityDocument = Schema.Struct({
  version: Schema.Literal(1),
  policies: Schema.Array(RemoteCompatibilityPolicy),
});

export type ProviderCompatibilityDocument = typeof RemoteCompatibilityDocument.Type;

type ProviderCompatibilitySnapshot = Pick<ServerProvider, "enabled" | "status" | "message"> & {
  readonly compatibilityAdvisory?: ServerProviderCompatibilityAdvisory | undefined;
};

const decodeCompatibilityDocument = Schema.decodeUnknownEffect(RemoteCompatibilityDocument);

/**
 * Repo-root compatibility JSON bundled into the app. Used when the remote map
 * cannot be fetched or has no matching policy for the current provider/build.
 */
const bundledProviderCompatibilityDocument = Schema.decodeUnknownSync(RemoteCompatibilityDocument)(
  bundledCompatibilityDocumentJson,
);

function remoteCompatibilityMapUrls(): ReadonlyArray<string> {
  const configured = process.env.T3_PROVIDER_COMPATIBILITY_MAP_URL?.trim();
  if (!configured) {
    return DEFAULT_PROVIDER_COMPATIBILITY_MAP_URLS;
  }
  const urls = configured
    .split(",")
    .map((url) => url.trim())
    .filter((url) => url.length > 0);
  return urls.length > 0 ? urls : DEFAULT_PROVIDER_COMPATIBILITY_MAP_URLS;
}

function policyMatches(input: {
  readonly policy: typeof RemoteCompatibilityPolicy.Type;
  readonly driver: ProviderDriverKind;
  readonly t3CodeVersion: string;
}): boolean {
  return (
    input.policy.driver === input.driver &&
    satisfiesSemverRange(input.t3CodeVersion, input.policy.t3CodeRange)
  );
}

function compatibilityPolicyForDriver(input: {
  readonly document: typeof RemoteCompatibilityDocument.Type;
  readonly driver: ProviderDriverKind;
  readonly t3CodeVersion?: string;
}): typeof RemoteCompatibilityPolicy.Type | null {
  const t3CodeVersion = input.t3CodeVersion ?? T3_CODE_VERSION;
  return (
    input.document.policies.find((policy) =>
      policyMatches({ policy, driver: input.driver, t3CodeVersion }),
    ) ?? null
  );
}

function severityForStatus(
  status: ServerProviderCompatibilityAdvisory["status"],
): ServerProviderCompatibilityAdvisory["severity"] {
  switch (status) {
    case "broken":
      return "error";
    case "unsupported":
    case "graceful":
      return "warning";
    case "supported":
    case "unknown":
      return "info";
  }
}

function messageForStatus(input: {
  readonly status: ServerProviderCompatibilityAdvisory["status"];
  readonly currentVersion: string | null;
  readonly recommendedRange: string | null;
  readonly recommendedVersion: string | null;
}) {
  const current = input.currentVersion ? ` ${input.currentVersion}` : "";
  const recommendedTarget = input.recommendedVersion ?? input.recommendedRange;
  const recommended = recommendedTarget ? ` Use ${recommendedTarget}.` : "";
  switch (input.status) {
    case "broken":
      return `This provider harness version${current} is known to be incompatible with this T3 Code release.${recommended}`;
    case "unsupported":
      return `This provider harness version${current} is outside the compatibility range for this T3 Code release.${recommended}`;
    case "graceful":
      return `This provider harness version${current} should still work, but updating is recommended.${recommended}`;
    case "unknown":
      return `T3 Code could not determine whether this provider harness version is compatible.${recommended}`;
    case "supported":
      return null;
  }
}

function createProviderCompatibilityAdvisoryFromDocument(input: {
  readonly document: typeof RemoteCompatibilityDocument.Type;
  readonly driver: ProviderDriverKind;
  readonly currentVersion: string | null;
  readonly maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined;
  readonly t3CodeVersion?: string;
}): ServerProviderCompatibilityAdvisory | undefined {
  const policy = compatibilityPolicyForDriver({
    document: input.document,
    driver: input.driver,
    ...(input.t3CodeVersion ? { t3CodeVersion: input.t3CodeVersion } : {}),
  });
  if (!policy) {
    return undefined;
  }

  const currentVersion = input.currentVersion;
  const matchedRange =
    currentVersion === null
      ? undefined
      : policy.ranges.find((range) => satisfiesSemverRange(currentVersion, range.range));
  const status = matchedRange?.status ?? (currentVersion === null ? "unknown" : "unsupported");
  const recommendedVersion = policy.recommendedVersion ?? null;
  const targetedUpdateAction = input.maintenanceCapabilities
    ? makeTargetedProviderUpdateAction(input.maintenanceCapabilities, recommendedVersion)
    : null;

  return {
    status,
    severity: severityForStatus(status),
    currentVersion: input.currentVersion,
    message: messageForStatus({
      status,
      currentVersion: input.currentVersion,
      recommendedRange: policy.recommendedRange,
      recommendedVersion,
    }),
    recommendedRange: policy.recommendedRange,
    recommendedVersion,
    updateCommand: targetedUpdateAction?.command ?? null,
    canUpdate: targetedUpdateAction !== null,
    ranges: [...policy.ranges],
  };
}

function shouldSkipCompatibilityAdvisory(input: {
  readonly snapshot: ProviderCompatibilitySnapshot;
  readonly currentVersion: string | null;
}): boolean {
  return !input.snapshot.enabled && input.currentVersion === null;
}

export function createProviderCompatibilityAdvisory(input: {
  readonly driver: ProviderDriverKind;
  readonly currentVersion: string | null;
  readonly document?: typeof RemoteCompatibilityDocument.Type;
  readonly maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined;
  readonly t3CodeVersion?: string;
}): ServerProviderCompatibilityAdvisory | undefined {
  return createProviderCompatibilityAdvisoryFromDocument({
    document: input.document ?? bundledProviderCompatibilityDocument,
    driver: input.driver,
    currentVersion: input.currentVersion,
    maintenanceCapabilities: input.maintenanceCapabilities,
    ...(input.t3CodeVersion ? { t3CodeVersion: input.t3CodeVersion } : {}),
  });
}

const fetchRemoteCompatibilityDocument = Effect.fn("fetchRemoteCompatibilityDocument")(
  function* (url: string) {
    const client = yield* HttpClient.HttpClient;
    const response = yield* client
      .execute(
        HttpClientRequest.get(url).pipe(
          HttpClientRequest.acceptJson,
          HttpClientRequest.setHeader("user-agent", `t3code/${T3_CODE_VERSION}`),
        ),
      )
      .pipe(Effect.timeoutOption(REMOTE_COMPATIBILITY_TIMEOUT));

    if (Option.isNone(response)) {
      return null;
    }

    const httpResponse = response.value;
    if (httpResponse.status < 200 || httpResponse.status >= 300) {
      return null;
    }

    const payload = yield* httpResponse.json.pipe(
      Effect.flatMap(decodeCompatibilityDocument),
      Effect.catch(() => Effect.succeed(null)),
    );
    return payload;
  },
  (effect, url) =>
    effect.pipe(
      Effect.tapError((cause) =>
        Effect.logWarning("provider compatibility map fetch failed", {
          cause,
          url,
        }),
      ),
      Effect.catch(() => Effect.succeed(null)),
    ),
);

function applyCompatibilityAdvisory<Snapshot extends ProviderCompatibilitySnapshot>(
  snapshot: Snapshot,
  compatibilityAdvisory: ServerProviderCompatibilityAdvisory | undefined,
): Snapshot {
  const baseSnapshot = removeExistingCompatibilityAdvisory(snapshot);
  if (!compatibilityAdvisory) {
    return baseSnapshot;
  }

  const status =
    baseSnapshot.enabled && compatibilityAdvisory.severity === "error"
      ? "error"
      : baseSnapshot.enabled &&
          compatibilityAdvisory.severity === "warning" &&
          baseSnapshot.status === "ready"
        ? "warning"
        : baseSnapshot.status;
  const compatibilityMessage =
    status !== baseSnapshot.status && compatibilityAdvisory.severity !== "info"
      ? (compatibilityAdvisory.message ?? undefined)
      : undefined;
  const advisoryWithPreState: ServerProviderCompatibilityAdvisory = {
    ...compatibilityAdvisory,
    preAdvisoryStatus: baseSnapshot.status,
    ...(baseSnapshot.message ? { preAdvisoryMessage: baseSnapshot.message } : {}),
  };

  return {
    ...baseSnapshot,
    status,
    ...(compatibilityMessage || baseSnapshot.message
      ? { message: compatibilityMessage ?? baseSnapshot.message }
      : {}),
    compatibilityAdvisory: advisoryWithPreState,
  } as Snapshot;
}

function removeExistingCompatibilityAdvisory<Snapshot extends ProviderCompatibilitySnapshot>(
  snapshot: Snapshot,
): Snapshot {
  if (!snapshot.compatibilityAdvisory) {
    return snapshot;
  }

  const { compatibilityAdvisory: existingCompatibilityAdvisory, ...baseSnapshot } = snapshot;
  const compatibilityMessage =
    existingCompatibilityAdvisory.severity !== "info"
      ? (existingCompatibilityAdvisory.message ?? undefined)
      : undefined;
  if (compatibilityMessage && baseSnapshot.message === compatibilityMessage) {
    const { message: _message, ...snapshotWithoutCompatibilityMessage } = baseSnapshot;
    const restoredStatus =
      existingCompatibilityAdvisory.preAdvisoryStatus ?? (snapshot.enabled ? "ready" : "disabled");
    return {
      ...snapshotWithoutCompatibilityMessage,
      status: restoredStatus,
      ...(existingCompatibilityAdvisory.preAdvisoryMessage
        ? { message: existingCompatibilityAdvisory.preAdvisoryMessage }
        : {}),
    } as Snapshot;
  }
  if (existingCompatibilityAdvisory.preAdvisoryStatus !== undefined) {
    return {
      ...baseSnapshot,
      status: existingCompatibilityAdvisory.preAdvisoryStatus,
    } as Snapshot;
  }
  return baseSnapshot as Snapshot;
}

export function applyBundledProviderCompatibilityAdvisory<
  Snapshot extends ProviderCompatibilitySnapshot,
>(input: {
  readonly snapshot: Snapshot;
  readonly driver: ProviderDriverKind;
  readonly currentVersion: string | null;
  readonly maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined;
}): Snapshot {
  if (
    shouldSkipCompatibilityAdvisory({
      snapshot: input.snapshot,
      currentVersion: input.currentVersion,
    })
  ) {
    return removeExistingCompatibilityAdvisory(input.snapshot);
  }

  return applyCompatibilityAdvisory(
    input.snapshot,
    createProviderCompatibilityAdvisory({
      driver: input.driver,
      currentVersion: input.currentVersion,
      maintenanceCapabilities: input.maintenanceCapabilities,
    }),
  );
}

export const enrichProviderSnapshotWithCompatibilityAdvisory = Effect.fn(
  "enrichProviderSnapshotWithCompatibilityAdvisory",
)(function* (snapshot: ServerProvider) {
  const compatibility = yield* ProviderCompatibilityService;
  return yield* compatibility.enrichSnapshot(snapshot);
});

export const enrichProviderSnapshotWithTargetedCompatibilityAdvisory = Effect.fn(
  "enrichProviderSnapshotWithTargetedCompatibilityAdvisory",
)(function* (snapshot: ServerProvider, maintenanceCapabilities: ProviderMaintenanceCapabilities) {
  const compatibility = yield* ProviderCompatibilityService;
  return yield* compatibility.enrichSnapshot(snapshot, maintenanceCapabilities);
});

export interface ProviderCompatibilityServiceShape {
  readonly resolveRemoteDocument: Effect.Effect<typeof RemoteCompatibilityDocument.Type | null>;
  readonly enrichSnapshot: (
    snapshot: ServerProvider,
    maintenanceCapabilities?: ProviderMaintenanceCapabilities | undefined,
  ) => Effect.Effect<ServerProvider>;
}

export class ProviderCompatibilityService extends Context.Service<
  ProviderCompatibilityService,
  ProviderCompatibilityServiceShape
>()("t3/provider/ProviderCompatibilityService") {}

export const makeProviderCompatibilityService = Effect.fn("makeProviderCompatibilityService")(
  function* () {
    const remoteDocumentCache = yield* Cache.makeWith(fetchRemoteCompatibilityDocument, {
      capacity: REMOTE_COMPATIBILITY_CACHE_CAPACITY,
      timeToLive: (exit) =>
        Exit.isSuccess(exit) && exit.value !== null
          ? REMOTE_COMPATIBILITY_CACHE_TTL
          : Duration.zero,
    });

    const resolveRemoteDocument = Effect.gen(function* () {
      for (const url of remoteCompatibilityMapUrls()) {
        const document = yield* Cache.get(remoteDocumentCache, url);
        if (document) {
          return document;
        }
      }

      return null;
    });

    return {
      resolveRemoteDocument,
      enrichSnapshot: (snapshot, maintenanceCapabilities) =>
        resolveRemoteDocument.pipe(
          Effect.map((remoteDocument) =>
            shouldSkipCompatibilityAdvisory({
              snapshot,
              currentVersion: snapshot.version,
            })
              ? removeExistingCompatibilityAdvisory(snapshot)
              : applyCompatibilityAdvisory(
                  snapshot,
                  createProviderCompatibilityAdvisory({
                    driver: snapshot.driver,
                    currentVersion: snapshot.version,
                    maintenanceCapabilities,
                    ...(remoteDocument ? { document: remoteDocument } : {}),
                  }),
                ),
          ),
        ),
    } satisfies ProviderCompatibilityServiceShape;
  },
);

export const layer = Layer.effect(ProviderCompatibilityService, makeProviderCompatibilityService());