import type { Event as OpenCodeEvent, OpencodeClient } from "@opencode-ai/sdk/v2";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { ProviderReplayEntry, type ProviderReplayTranscript } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Duration from "effect/Duration";
import * as Layer from "effect/Layer";
import * as Schema from "effect/Schema";

import { ServerConfig } from "../../config.ts";
import {
  OpenCodeRuntime,
  OpenCodeRuntimeError,
  type OpenCodeRuntimeShape,
} from "../../provider/opencodeRuntime.ts";
import {
  NoOpProviderEventLoggers,
  ProviderEventLoggers,
} from "../../provider/Layers/ProviderEventLoggers.ts";
import { layer as idAllocatorLayer } from "../IdAllocator.ts";
import { ProviderAdapterDriverCreateError } from "../ProviderAdapterDriver.ts";
import { makeDriverLayer as makeProviderAdapterRegistryDriverLayer } from "../ProviderAdapterRegistry.ts";
import {
  makeReplayServerConfig,
  type OrchestratorV2ProviderReplayHarness,
} from "../testkit/ProviderReplayHarness.ts";
import {
  OPENCODE_DEFAULT_INSTANCE_ID,
  OPENCODE_DRIVER_KIND,
  OPENCODE_PROVIDER,
  OPENCODE_SDK_PROTOCOL,
  OpenCodeAdapterV2Driver,
} from "./OpenCodeAdapterV2.ts";

export const OPENCODE_SDK_REPLAY_PROTOCOL = OPENCODE_SDK_PROTOCOL;

const OpenCodeSdkReplayTranscript = Schema.Struct({
  provider: Schema.Literal(OPENCODE_PROVIDER),
  protocol: Schema.Literal(OPENCODE_SDK_REPLAY_PROTOCOL),
  version: Schema.String,
  scenario: Schema.String,
  metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown)),
  entries: Schema.Array(ProviderReplayEntry),
});
export type OpenCodeSdkReplayTranscript = typeof OpenCodeSdkReplayTranscript.Type;
const decodeOpenCodeSdkReplayTranscript = Schema.decodeUnknownEffect(OpenCodeSdkReplayTranscript);

export class OpenCodeReplayTranscriptDecodeError extends Schema.TaggedErrorClass<OpenCodeReplayTranscriptDecodeError>()(
  "OpenCodeReplayTranscriptDecodeError",
  {
    driver: Schema.optional(Schema.String),
    protocol: Schema.optional(Schema.String),
    scenario: Schema.optional(Schema.String),
    cause: Schema.Defect(),
  },
) {
  override get message(): string {
    return `Failed to decode OpenCode replay transcript for scenario ${this.scenario ?? "<unknown>"}.`;
  }
}

export class OpenCodeReplayMismatchError extends Schema.TaggedErrorClass<OpenCodeReplayMismatchError>()(
  "OpenCodeReplayMismatchError",
  {
    scenario: Schema.String,
    cursor: Schema.Number,
    expected: Schema.Unknown,
    actual: Schema.Unknown,
  },
) {
  override get message(): string {
    return `OpenCode replay frame mismatch at cursor ${this.cursor} in scenario ${this.scenario}.`;
  }
}

export class OpenCodeReplayIncompleteError extends Schema.TaggedErrorClass<OpenCodeReplayIncompleteError>()(
  "OpenCodeReplayIncompleteError",
  {
    scenario: Schema.String,
    cursor: Schema.Number,
    remaining: Schema.Number,
  },
) {
  override get message(): string {
    return `OpenCode replay ended with ${this.remaining} unconsumed entries in scenario ${this.scenario}.`;
  }
}

export const OpenCodeReplayError = Schema.Union([
  OpenCodeReplayTranscriptDecodeError,
  OpenCodeReplayMismatchError,
  OpenCodeReplayIncompleteError,
]);
export type OpenCodeReplayError = typeof OpenCodeReplayError.Type;
export const OpenCodeOrchestratorReplayHarnessError = Schema.Union([
  OpenCodeReplayError,
  ProviderAdapterDriverCreateError,
]);
export type OpenCodeOrchestratorReplayHarnessError =
  typeof OpenCodeOrchestratorReplayHarnessError.Type;

function replayValueMatches(expected: unknown, actual: unknown): boolean {
  if (expected === "<any>" || expected === "<workspace>") return true;
  if (Array.isArray(expected)) {
    return (
      Array.isArray(actual) &&
      expected.length === actual.length &&
      expected.every((entry, index) => replayValueMatches(entry, actual[index]))
    );
  }
  if (typeof expected === "object" && expected !== null) {
    if (typeof actual !== "object" || actual === null) return false;
    return Object.entries(expected).every(([key, value]) =>
      replayValueMatches(value, (actual as Record<string, unknown>)[key]),
    );
  }
  return Object.is(expected, actual);
}

function frameRecord(frame: unknown): Record<string, unknown> | null {
  return typeof frame === "object" && frame !== null ? (frame as Record<string, unknown>) : null;
}

function materializeMessageIds(value: unknown, messageIds: ReadonlyMap<string, string>): unknown {
  if (Array.isArray(value)) return value.map((entry) => materializeMessageIds(entry, messageIds));
  const record = frameRecord(value);
  if (record === null) return value;
  return Object.fromEntries(
    Object.entries(record).map(([key, entry]) => [
      key,
      typeof entry === "string" && (key === "id" || key === "messageID" || key === "parentID")
        ? (messageIds.get(entry) ?? entry)
        : materializeMessageIds(entry, messageIds),
    ]),
  );
}

export class OpenCodeReplayController {
  private cursor = 0;
  private readonly waiters = new Set<() => void>();
  private failure: unknown = null;
  private readonly transcript: OpenCodeSdkReplayTranscript;
  private messageIds = new Map<string, string>();

  constructor(transcript: OpenCodeSdkReplayTranscript) {
    this.transcript = transcript;
  }

  async expectOutbound(actual: unknown): Promise<void> {
    try {
      const entry = this.transcript.entries[this.cursor];
      const expectedFrame = entry?.type === "expect_outbound" ? frameRecord(entry.frame) : null;
      const actualFrame = frameRecord(actual);
      const messageIds = new Map(this.messageIds);
      let conflictingMessageId = false;
      if (
        expectedFrame?.type === "session.promptAsync" &&
        actualFrame?.type === expectedFrame.type
      ) {
        const recordedId = frameRecord(expectedFrame.input)?.messageID;
        const actualId = frameRecord(actualFrame.input)?.messageID;
        if (
          typeof recordedId === "string" &&
          typeof actualId === "string" &&
          recordedId !== "<any>" &&
          recordedId !== "<workspace>" &&
          !messageIds.has(recordedId)
        ) {
          conflictingMessageId = [...messageIds.values()].includes(actualId);
          if (!conflictingMessageId) messageIds.set(recordedId, actualId);
        }
      }
      const expected =
        entry?.type === "expect_outbound"
          ? materializeMessageIds(entry.frame, messageIds)
          : (entry ?? null);
      if (
        conflictingMessageId ||
        entry?.type !== "expect_outbound" ||
        !replayValueMatches(expected, actual)
      ) {
        throw new OpenCodeReplayMismatchError({
          scenario: this.transcript.scenario,
          cursor: this.cursor,
          expected,
          actual,
        });
      }
      this.messageIds = messageIds;
      this.advance();
    } catch (cause) {
      this.fail(cause);
      throw cause;
    }
  }

  async response(operation: string): Promise<unknown> {
    while (true) {
      this.throwFailure();
      const entry = this.transcript.entries[this.cursor];
      if (entry?.type === "emit_inbound") {
        const frame = frameRecord(entry.frame);
        if (frame?.type === "sdk.response" && frame.operation === operation) {
          if (entry.afterMs !== undefined && entry.afterMs > 0) {
            await Effect.runPromise(Effect.sleep(Duration.millis(entry.afterMs)));
          }
          const data = materializeMessageIds(frame.data, this.messageIds);
          this.advance();
          return data;
        }
      }
      if (entry?.type === "runtime_exit") {
        const mismatch = new OpenCodeReplayMismatchError({
          scenario: this.transcript.scenario,
          cursor: this.cursor,
          expected: { type: "sdk.response", operation },
          actual: entry,
        });
        this.fail(mismatch);
        throw mismatch;
      }
      await this.changed();
    }
  }

  async *events(signal?: AbortSignal): AsyncIterable<OpenCodeEvent> {
    while (true) {
      if (signal?.aborted === true) return;
      this.throwFailure();
      const entry = this.transcript.entries[this.cursor];
      if (entry?.type === "emit_inbound") {
        const frame = frameRecord(entry.frame);
        if (frame?.type === "sdk.event") {
          if (entry.afterMs !== undefined && entry.afterMs > 0) {
            await Effect.runPromise(Effect.sleep(Duration.millis(entry.afterMs)));
          }
          const event = materializeMessageIds(frame.event, this.messageIds) as OpenCodeEvent;
          this.advance();
          yield event;
          continue;
        }
      }
      if (entry?.type === "runtime_exit") {
        this.advance();
        if (entry.status === "success") return;
        const mismatch = new OpenCodeReplayMismatchError({
          scenario: this.transcript.scenario,
          cursor: this.cursor - 1,
          expected: { status: "success" },
          actual: entry,
        });
        this.fail(mismatch);
        throw mismatch;
      }
      await this.changed(signal);
    }
  }

  assertComplete(): void {
    while (this.transcript.entries[this.cursor]?.type === "runtime_exit") {
      const exit = this.transcript.entries[this.cursor];
      if (exit?.type !== "runtime_exit" || exit.status !== "success") break;
      this.cursor += 1;
    }
    this.throwFailure();
    if (this.cursor !== this.transcript.entries.length) {
      throw new OpenCodeReplayIncompleteError({
        scenario: this.transcript.scenario,
        cursor: this.cursor,
        remaining: this.transcript.entries.length - this.cursor,
      });
    }
  }

  private advance(): void {
    this.cursor += 1;
    for (const waiter of this.waiters) waiter();
    this.waiters.clear();
  }

  private fail(cause: unknown): void {
    this.failure = cause;
    for (const waiter of this.waiters) waiter();
    this.waiters.clear();
  }

  private throwFailure(): void {
    if (this.failure !== null) throw this.failure;
  }

  private changed(signal?: AbortSignal): Promise<void> {
    return new Promise((resolve) => {
      let settled = false;
      const done = () => {
        if (settled) return;
        settled = true;
        signal?.removeEventListener("abort", done);
        this.waiters.delete(done);
        resolve();
      };
      this.waiters.add(done);
      signal?.addEventListener("abort", done, { once: true });
      if (signal?.aborted === true) done();
    });
  }
}

function makeReplayClient(controller: OpenCodeReplayController): OpencodeClient {
  const request = async (operation: string, input: unknown) => {
    await controller.expectOutbound({ type: operation, input });
    return { data: await controller.response(operation) };
  };
  return {
    event: {
      subscribe: async (_input?: unknown, options?: { readonly signal?: AbortSignal }) => {
        await controller.expectOutbound({ type: "event.subscribe" });
        return { stream: controller.events(options?.signal) };
      },
    },
    session: {
      create: (input: unknown) => request("session.create", input),
      get: (input: unknown) => request("session.get", input),
      update: (input: unknown) => request("session.update", input),
      messages: (input: unknown) => request("session.messages", input),
      promptAsync: (input: unknown) => request("session.promptAsync", input),
      abort: (input: unknown) => request("session.abort", input),
      revert: (input: unknown) => request("session.revert", input),
      unrevert: (input: unknown) => request("session.unrevert", input),
      fork: (input: unknown) => request("session.fork", input),
    },
    permission: {
      reply: (input: unknown) => request("permission.reply", input),
    },
    question: {
      reply: (input: unknown) => request("question.reply", input),
    },
    mcp: {
      add: (input: unknown) => request("mcp.add", input),
    },
  } as unknown as OpencodeClient;
}

function makeOpenCodeReplayRuntimeLayer(transcript: OpenCodeSdkReplayTranscript) {
  return Layer.effect(
    OpenCodeRuntime,
    Effect.gen(function* () {
      const controller = new OpenCodeReplayController(transcript);
      yield* Effect.addFinalizer(() =>
        Effect.sync(() => {
          controller.assertComplete();
        }),
      );
      const client = makeReplayClient(controller);
      return OpenCodeRuntime.of({
        startOpenCodeServerProcess: () =>
          Effect.fail(
            new OpenCodeRuntimeError({
              operation: "startOpenCodeServerProcess",
              detail: "OpenCode replay uses an external in-memory SDK boundary.",
            }),
          ),
        connectToOpenCodeServer: () =>
          Effect.succeed({
            url: "replay://opencode",
            version: "0.0.0-replay",
            exitCode: null,
            external: true,
          }),
        runOpenCodeCommand: () =>
          Effect.fail(
            new OpenCodeRuntimeError({
              operation: "runOpenCodeCommand",
              detail: "OpenCode replay does not execute commands.",
            }),
          ),
        createOpenCodeSdkClient: () => client,
        loadOpenCodeInventory: () =>
          Effect.fail(
            new OpenCodeRuntimeError({
              operation: "loadOpenCodeInventory",
              detail: "OpenCode replay does not load inventory.",
            }),
          ),
        loadInventoryFromCli: () =>
          Effect.fail(
            new OpenCodeRuntimeError({
              operation: "loadInventoryFromCli",
              detail: "OpenCode replay does not load inventory.",
            }),
          ),
        loadOpenCodeSkills: () =>
          Effect.fail(
            new OpenCodeRuntimeError({
              operation: "loadOpenCodeSkills",
              detail: "OpenCode replay does not load skills.",
            }),
          ),
        loadSkillsFromCli: () =>
          Effect.fail(
            new OpenCodeRuntimeError({
              operation: "loadSkillsFromCli",
              detail: "OpenCode replay does not load skills.",
            }),
          ),
      } satisfies OpenCodeRuntimeShape);
    }),
  );
}

export function makeOpenCodeProviderAdapterRegistryReplayLayer(
  transcript: OpenCodeSdkReplayTranscript,
) {
  const serverConfigLayer = Layer.effect(
    ServerConfig,
    makeReplayServerConfig(transcript.scenario).pipe(Effect.orDie),
  ).pipe(Layer.provide(NodeServices.layer));
  return makeProviderAdapterRegistryDriverLayer({
    drivers: [OpenCodeAdapterV2Driver],
    configMap: {
      [OPENCODE_DEFAULT_INSTANCE_ID]: {
        driver: OPENCODE_DRIVER_KIND,
        config: { serverUrl: "replay://opencode" },
      },
    },
  }).pipe(
    Layer.provide(
      Layer.mergeAll(
        makeOpenCodeReplayRuntimeLayer(transcript),
        serverConfigLayer,
        NodeServices.layer,
        idAllocatorLayer,
        Layer.succeed(ProviderEventLoggers, NoOpProviderEventLoggers),
      ),
    ),
  );
}

function transcriptMetadata(transcript: ProviderReplayTranscript) {
  return {
    provider: transcript.provider,
    protocol: transcript.protocol,
    scenario: transcript.scenario,
  };
}

export const OpenCodeOrchestratorReplayHarness: OrchestratorV2ProviderReplayHarness<
  OpenCodeSdkReplayTranscript,
  OpenCodeOrchestratorReplayHarnessError
> = {
  driver: OPENCODE_PROVIDER,
  decodeTranscript: (transcript) =>
    decodeOpenCodeSdkReplayTranscript(transcript).pipe(
      Effect.mapError(
        (cause) =>
          new OpenCodeReplayTranscriptDecodeError({
            ...transcriptMetadata(transcript),
            cause,
          }),
      ),
    ),
  makeProviderAdapterRegistryLayer: makeOpenCodeProviderAdapterRegistryReplayLayer,
};