import * as NodeServices from "@effect/platform-node/NodeServices";
import { ProviderDriverKind, ThreadId } from "@t3tools/contracts";
import { assert, it } from "@effect/vitest";
import * as Cause from "effect/Cause";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Logger from "effect/Logger";
import * as Schema from "effect/Schema";
import * as AcpErrors from "effect-acp/errors";

import type { EventNdjsonLogger } from "../Layers/EventNdjsonLogger.ts";
import { makeAcpNativeLoggerFactory } from "./AcpNativeLogging.ts";

const nodeServicesIt = it.layer(NodeServices.layer);
const encodeUnknownJson = Schema.encodeUnknownSync(Schema.fromJsonString(Schema.Unknown));

nodeServicesIt("ACP native logging", (it) => {
  it.effect("records bounded request and protocol diagnostics without raw payloads", () =>
    Effect.gen(function* () {
      const records: Array<unknown> = [];
      const nativeEventLogger: EventNdjsonLogger = {
        filePath: "/tmp/provider-native.ndjson",
        write: (event) => Effect.sync(() => void records.push(event)),
        close: () => Effect.void,
      };
      const makeLogger = yield* makeAcpNativeLoggerFactory();
      const logger = makeLogger({
        nativeEventLogger,
        provider: ProviderDriverKind.make("cursor"),
        threadId: ThreadId.make("thread-1"),
        verboseProtocolLogging: true,
      });
      const secret = "secret-token-value";
      const requestLogger = logger.requestLogger;
      const protocolLogger = logger.protocolLogging?.logger;
      assert.exists(requestLogger);
      assert.exists(protocolLogger);
      if (!requestLogger || !protocolLogger) return;

      yield* requestLogger({
        method: "session/prompt",
        payload: { prompt: secret, sessionId: secret },
        status: "failed",
        cause: Cause.fail(AcpErrors.AcpRequestError.internalError(secret, { token: secret })),
      });
      yield* protocolLogger({
        direction: "incoming",
        stage: "raw",
        payload: `{"token":"${secret}"}`,
      });
      yield* protocolLogger({
        direction: "outgoing",
        stage: "decoded",
        payload: {
          _tag: "Request",
          tag: "session/prompt",
          payload: { prompt: secret },
        },
      });

      const serialized = encodeUnknownJson(records);
      assert.notInclude(serialized, secret);
      assert.include(serialized, '"method":"session/prompt"');
      assert.include(serialized, '"errorTag":"AcpRequestError"');
      assert.include(serialized, '"reasonCount":1');
      assert.include(serialized, '"valueType":"string"');
      assert.include(serialized, '"messageTag":"Request"');
    }),
  );

  it.effect("keeps request diagnostics without enabling full protocol logging", () =>
    Effect.gen(function* () {
      const records: Array<unknown> = [];
      const makeLogger = yield* makeAcpNativeLoggerFactory();
      const logger = makeLogger({
        nativeEventLogger: {
          filePath: "/tmp/provider-native.ndjson",
          write: (event) => Effect.sync(() => void records.push(event)),
          close: () => Effect.void,
        },
        provider: ProviderDriverKind.make("grok"),
        threadId: ThreadId.make("thread-1"),
      });

      assert.isUndefined(logger.protocolLogging);
      const requestLogger = logger.requestLogger;
      assert.exists(requestLogger);
      if (!requestLogger) return;
      yield* requestLogger({
        method: "session/prompt",
        payload: {},
        status: "started",
      });
      assert.lengthOf(records, 1);
    }),
  );

  it.effect("drops transient ACP chunks before formatting verbose protocol logs", () =>
    Effect.gen(function* () {
      const records: Array<unknown> = [];
      const makeLogger = yield* makeAcpNativeLoggerFactory();
      const logger = makeLogger({
        nativeEventLogger: {
          filePath: "/tmp/provider-native.ndjson",
          write: (event) => Effect.sync(() => void records.push(event)),
          close: () => Effect.void,
        },
        provider: ProviderDriverKind.make("cursor"),
        threadId: ThreadId.make("thread-1"),
        verboseProtocolLogging: true,
      });
      const protocolLogger = logger.protocolLogging?.logger;
      assert.exists(protocolLogger);
      if (!protocolLogger) return;

      for (const updateType of ["agent_message_chunk", "agent_thought_chunk"] as const) {
        yield* protocolLogger({
          direction: "incoming",
          stage: "raw",
          payload: `${encodeUnknownJson({
            method: "session/update",
            params: { update: { sessionUpdate: updateType } },
          })}\n`,
        });
        yield* protocolLogger({
          direction: "incoming",
          stage: "decoded",
          payload: [
            {
              _tag: "Request",
              tag: "session/update",
              payload: { update: { sessionUpdate: updateType } },
            },
          ],
        });
      }

      assert.lengthOf(records, 0);

      yield* protocolLogger({
        direction: "incoming",
        stage: "decoded",
        payload: [
          {
            _tag: "Request",
            tag: "session/update",
            payload: { update: { sessionUpdate: "tool_call" } },
          },
        ],
      });
      assert.lengthOf(records, 1);
    }),
  );

  it.effect("keeps mixed and incomplete raw diagnostics", () =>
    Effect.gen(function* () {
      const records: Array<unknown> = [];
      const makeLogger = yield* makeAcpNativeLoggerFactory();
      const logger = makeLogger({
        nativeEventLogger: {
          filePath: "/tmp/provider-native.ndjson",
          write: (event) => Effect.sync(() => void records.push(event)),
          close: () => Effect.void,
        },
        provider: ProviderDriverKind.make("cursor"),
        threadId: ThreadId.make("thread-1"),
        verboseProtocolLogging: true,
      });
      const protocolLogger = logger.protocolLogging?.logger;
      assert.exists(protocolLogger);
      if (!protocolLogger) return;

      const transient = encodeUnknownJson({
        method: "session/update",
        params: { update: { sessionUpdate: "agent_message_chunk" } },
      });
      const lifecycle = encodeUnknownJson({ method: "session/new", params: {} });

      yield* protocolLogger({
        direction: "incoming",
        stage: "raw",
        payload: `${transient}\n${lifecycle}\n`,
      });
      yield* protocolLogger({
        direction: "incoming",
        stage: "raw",
        payload: transient,
      });
      yield* protocolLogger({
        direction: "incoming",
        stage: "raw",
        payload: `${transient}\n{malformed}\n`,
      });

      assert.lengthOf(records, 3);
    }),
  );

  it.effect("filters transient entries from mixed decoded batches", () =>
    Effect.gen(function* () {
      const records: Array<unknown> = [];
      const makeLogger = yield* makeAcpNativeLoggerFactory();
      const logger = makeLogger({
        nativeEventLogger: {
          filePath: "/tmp/provider-native.ndjson",
          write: (event) => Effect.sync(() => void records.push(event)),
          close: () => Effect.void,
        },
        provider: ProviderDriverKind.make("grok"),
        threadId: ThreadId.make("thread-1"),
        verboseProtocolLogging: true,
      });
      const protocolLogger = logger.protocolLogging?.logger;
      assert.exists(protocolLogger);
      if (!protocolLogger) return;

      yield* protocolLogger({
        direction: "incoming",
        stage: "decoded",
        payload: [
          {
            _tag: "Request",
            tag: "session/update",
            payload: { update: { sessionUpdate: "agent_thought_chunk" } },
          },
          {
            _tag: "Request",
            tag: "session/new",
            payload: {},
          },
        ],
      });

      assert.lengthOf(records, 1);
      assert.include(encodeUnknownJson(records), '"itemCount":1');
    }),
  );

  it.effect("logs a structural tag when the native writer defects", () => {
    const messages: Array<unknown> = [];
    const logCapture = Logger.make<unknown, void>(({ message }) => {
      if (Array.isArray(message)) {
        messages.push(...message);
      } else {
        messages.push(message);
      }
    });
    const secret = "secret-writer-failure";

    return Effect.gen(function* () {
      const makeLogger = yield* makeAcpNativeLoggerFactory();
      const logger = makeLogger({
        nativeEventLogger: {
          filePath: "/tmp/provider-native.ndjson",
          write: () => Effect.die(new Error(secret)),
          close: () => Effect.void,
        },
        provider: ProviderDriverKind.make("cursor"),
        threadId: ThreadId.make("thread-1"),
      });
      const requestLogger = logger.requestLogger;
      assert.exists(requestLogger);
      if (!requestLogger) return;

      yield* requestLogger({
        method: "session/prompt",
        payload: {},
        status: "started",
      });

      const serialized = encodeUnknownJson(messages);
      assert.notInclude(serialized, secret);
      assert.include(serialized, '"errorTag":"Die"');
      assert.include(serialized, '"reasonCount":1');
    }).pipe(Effect.provide(Logger.layer([logCapture], { mergeWithExisting: false })));
  });

  it.effect("preserves native writer interruption", () =>
    Effect.gen(function* () {
      const makeLogger = yield* makeAcpNativeLoggerFactory();
      const logger = makeLogger({
        nativeEventLogger: {
          filePath: "/tmp/provider-native.ndjson",
          write: () => Effect.interrupt,
          close: () => Effect.void,
        },
        provider: ProviderDriverKind.make("cursor"),
        threadId: ThreadId.make("thread-1"),
      });
      const requestLogger = logger.requestLogger;
      assert.exists(requestLogger);
      if (!requestLogger) return;

      const exit = yield* requestLogger({
        method: "session/prompt",
        payload: {},
        status: "started",
      }).pipe(Effect.exit);

      assert.isTrue(Exit.isFailure(exit));
      if (Exit.isFailure(exit)) {
        assert.isTrue(Cause.hasInterruptsOnly(exit.cause));
      }
    }),
  );
});