import type { OpenCodeSettings, ServerProvider } from "@t3tools/contracts";
import { Cause, Effect, Equal, Layer, Stream } from "effect";

import { ServerConfig } from "../../config.ts";
import { ServerSettingsService } from "../../serverSettings.ts";
import { makeManagedServerProvider } from "../makeManagedServerProvider.ts";
import {
  buildServerProvider,
  isCommandMissingCause,
  parseGenericCliVersion,
  providerModelsFromSettings,
} from "../providerSnapshot.ts";
import { OpenCodeProvider } from "../Services/OpenCodeProvider.ts";
import {
  connectToOpenCodeServer,
  DEFAULT_OPENCODE_MODEL_CAPABILITIES,
  createOpenCodeSdkClient,
  flattenOpenCodeModels,
  loadOpenCodeInventory,
  runOpenCodeCommand,
} from "../opencodeRuntime.ts";

const PROVIDER = "opencode" as const;

class OpenCodeProbePromiseError extends Error {
  override readonly cause: unknown;

  constructor(cause: unknown) {
    super(cause instanceof Error ? cause.message : String(cause));
    this.cause = cause;
    this.name = "OpenCodeProbePromiseError";
  }
}

function toOpenCodeProbeError(cause: unknown): OpenCodeProbePromiseError {
  return new OpenCodeProbePromiseError(cause);
}

function normalizedErrorMessage(cause: unknown): string | undefined {
  if (!(cause instanceof Error)) {
    return undefined;
  }

  const message = cause.message.trim();
  if (message.length === 0) {
    return undefined;
  }
  if (
    message === "An error occurred in Effect.tryPromise" ||
    message === "An error occurred in Effect.try"
  ) {
    return undefined;
  }
  return message;
}

function formatOpenCodeProbeError(input: {
  readonly cause: unknown;
  readonly isExternalServer: boolean;
  readonly serverUrl: string;
}): { readonly installed: boolean; readonly message: string } {
  const lower = input.cause instanceof Error ? input.cause.message.toLowerCase() : "";
  const detail = normalizedErrorMessage(input.cause);

  if (input.isExternalServer) {
    if (
      lower.includes("401") ||
      lower.includes("403") ||
      lower.includes("unauthorized") ||
      lower.includes("forbidden")
    ) {
      return {
        installed: true,
        message: "OpenCode server rejected authentication. Check the server URL and password.",
      };
    }

    if (
      lower.includes("econnrefused") ||
      lower.includes("enotfound") ||
      lower.includes("fetch failed") ||
      lower.includes("networkerror") ||
      lower.includes("timed out") ||
      lower.includes("timeout") ||
      lower.includes("socket hang up")
    ) {
      return {
        installed: true,
        message: `Couldn't reach the configured OpenCode server at ${input.serverUrl}. Check that the server is running and the URL is correct.`,
      };
    }

    return {
      installed: true,
      message: detail ?? "Failed to connect to the configured OpenCode server.",
    };
  }

  if (input.cause instanceof Error && isCommandMissingCause(input.cause)) {
    return {
      installed: false,
      message: "OpenCode CLI (`opencode`) is not installed or not on PATH.",
    };
  }

  if (lower.includes("quarantine")) {
    return {
      installed: true,
      message:
        "macOS is blocking the OpenCode binary (quarantine). Run `xattr -d com.apple.quarantine $(which opencode)` to fix this.",
    };
  }

  if (lower.includes("invalid code signature") || lower.includes("corrupted")) {
    return {
      installed: true,
      message:
        "macOS killed the OpenCode process due to an invalid code signature. The binary may be corrupted — try reinstalling OpenCode.",
    };
  }

  return {
    installed: true,
    message: detail
      ? `Failed to execute OpenCode CLI health check: ${detail}`
      : "Failed to execute OpenCode CLI health check.",
  };
}

const makePendingOpenCodeProvider = (openCodeSettings: OpenCodeSettings): ServerProvider => {
  const checkedAt = new Date().toISOString();
  const models = providerModelsFromSettings(
    [],
    PROVIDER,
    openCodeSettings.customModels,
    DEFAULT_OPENCODE_MODEL_CAPABILITIES,
  );

  if (!openCodeSettings.enabled) {
    return buildServerProvider({
      provider: PROVIDER,
      enabled: false,
      checkedAt,
      models,
      probe: {
        installed: false,
        version: null,
        status: "warning",
        auth: { status: "unknown" },
        message:
          openCodeSettings.serverUrl.trim().length > 0
            ? "OpenCode is disabled in T3 Code settings. A server URL is configured."
            : "OpenCode is disabled in T3 Code settings.",
      },
    });
  }

  return buildServerProvider({
    provider: PROVIDER,
    enabled: true,
    checkedAt,
    models,
    probe: {
      installed: false,
      version: null,
      status: "warning",
      auth: { status: "unknown" },
      message: "OpenCode provider status has not been checked in this session yet.",
    },
  });
};

export function checkOpenCodeProviderStatus(input: {
  readonly settings: OpenCodeSettings;
  readonly cwd: string;
}): Effect.Effect<ServerProvider> {
  const checkedAt = new Date().toISOString();
  const customModels = input.settings.customModels;
  const isExternalServer = input.settings.serverUrl.trim().length > 0;

  const fallback = (cause: unknown, version: string | null = null) => {
    const failure = formatOpenCodeProbeError({
      cause,
      isExternalServer,
      serverUrl: input.settings.serverUrl,
    });
    return buildServerProvider({
      provider: PROVIDER,
      enabled: input.settings.enabled,
      checkedAt,
      models: providerModelsFromSettings(
        [],
        PROVIDER,
        customModels,
        DEFAULT_OPENCODE_MODEL_CAPABILITIES,
      ),
      probe: {
        installed: failure.installed,
        version,
        status: "error",
        auth: { status: "unknown" },
        message: failure.message,
      },
    });
  };

  return Effect.gen(function* () {
    if (!input.settings.enabled) {
      return buildServerProvider({
        provider: PROVIDER,
        enabled: false,
        checkedAt,
        models: providerModelsFromSettings(
          [],
          PROVIDER,
          customModels,
          DEFAULT_OPENCODE_MODEL_CAPABILITIES,
        ),
        probe: {
          installed: false,
          version: null,
          status: "warning",
          auth: { status: "unknown" },
          message: isExternalServer
            ? "OpenCode is disabled in T3 Code settings. A server URL is configured."
            : "OpenCode is disabled in T3 Code settings.",
        },
      });
    }

    let version: string | null = null;
    if (!isExternalServer) {
      const versionExit = yield* Effect.exit(
        Effect.tryPromise({
          try: () =>
            runOpenCodeCommand({
              binaryPath: input.settings.binaryPath,
              args: ["--version"],
            }),
          catch: toOpenCodeProbeError,
        }),
      );
      if (versionExit._tag === "Failure") {
        return fallback(Cause.squash(versionExit.cause));
      }
      version = parseGenericCliVersion(versionExit.value.stdout) ?? null;
    }

    const inventoryExit = yield* Effect.exit(
      Effect.acquireUseRelease(
        Effect.tryPromise({
          try: () =>
            connectToOpenCodeServer({
              binaryPath: input.settings.binaryPath,
              serverUrl: input.settings.serverUrl,
            }),
          catch: toOpenCodeProbeError,
        }),
        (server) =>
          Effect.tryPromise({
            try: async () => {
              const client = createOpenCodeSdkClient({
                baseUrl: server.url,
                directory: input.cwd,
                ...(isExternalServer && input.settings.serverPassword
                  ? { serverPassword: input.settings.serverPassword }
                  : {}),
              });
              return await loadOpenCodeInventory(client);
            },
            catch: toOpenCodeProbeError,
          }),
        (server) => Effect.sync(() => server.close()),
      ),
    );
    if (inventoryExit._tag === "Failure") {
      return fallback(Cause.squash(inventoryExit.cause), version);
    }

    const models = providerModelsFromSettings(
      flattenOpenCodeModels(inventoryExit.value),
      PROVIDER,
      customModels,
      DEFAULT_OPENCODE_MODEL_CAPABILITIES,
    );
    const connectedCount = inventoryExit.value.providerList.connected.length;
    return buildServerProvider({
      provider: PROVIDER,
      enabled: true,
      checkedAt,
      models,
      probe: {
        installed: true,
        version,
        status: connectedCount > 0 ? "ready" : "warning",
        auth: {
          status: connectedCount > 0 ? "authenticated" : "unknown",
          type: "opencode",
        },
        message:
          connectedCount > 0
            ? `${connectedCount} upstream provider${connectedCount === 1 ? "" : "s"} connected through ${isExternalServer ? "the configured OpenCode server" : "OpenCode"}.`
            : isExternalServer
              ? "Connected to the configured OpenCode server, but it did not report any connected upstream providers."
              : "OpenCode is available, but it did not report any connected upstream providers.",
      },
    });
  });
}

export function makeOpenCodeProviderLive() {
  return Layer.effect(
    OpenCodeProvider,
    Effect.gen(function* () {
      const serverSettings = yield* ServerSettingsService;
      const serverConfig = yield* ServerConfig;

      const getProviderSettings = serverSettings.getSettings.pipe(
        Effect.map((settings) => settings.providers.opencode),
      );

      return yield* makeManagedServerProvider<OpenCodeSettings>({
        getSettings: getProviderSettings.pipe(Effect.orDie),
        streamSettings: serverSettings.streamChanges.pipe(
          Stream.map((settings) => settings.providers.opencode),
        ),
        haveSettingsChanged: (previous, next) => !Equal.equals(previous, next),
        initialSnapshot: makePendingOpenCodeProvider,
        checkProvider: getProviderSettings.pipe(
          Effect.flatMap((settings) =>
            checkOpenCodeProviderStatus({
              settings,
              cwd: serverConfig.cwd,
            }),
          ),
        ),
      });
    }),
  );
}

export const OpenCodeProviderLive = makeOpenCodeProviderLive();