import { Effect, Predicate, Schema } from "effect";
import { sha256Hex, type Owner } from "@executor-js/sdk";

import type { AppToolExecutor, CollectedTool } from "../executor/app-tool-executor";
import type { AppsStore } from "../plugin/store";
import { bundleEntry, defaultBundleBackend, type BundleBackend } from "./bundle";
import {
  DESCRIPTOR_VERSION,
  stableStringify,
  type AppDescriptor,
  type ModuleSourceRef,
  type ToolDescriptor,
} from "./descriptor";
import { discover, PublishError, type SkippedArtifact } from "./discover";
export { PublishError } from "./discover";

export const PUBLISH_LIMITS = {
  maxFiles: 256,
  maxFileBytes: 1024 * 1024,
  maxTotalBytes: 4 * 1024 * 1024,
} as const;

export interface PublishFile {
  readonly path: string;
  readonly bytes: Uint8Array;
}

export interface PublishInput {
  readonly app: string;
  readonly owner?: Owner;
  readonly files: readonly PublishFile[];
  readonly sourceRef: string;
}

export interface PublishResult {
  readonly descriptor: AppDescriptor;
  readonly publishedTools: readonly string[];
  readonly skipped: readonly SkippedArtifact[];
  readonly noop: boolean;
}

export interface PublishDeps {
  readonly store: AppsStore;
  readonly executor: AppToolExecutor;
  readonly bundler?: BundleBackend;
  readonly now?: () => number;
}

const textDecoder = new TextDecoder();
const textEncoder = new TextEncoder();

const byteLength = (value: Uint8Array | string): number =>
  typeof value === "string" ? textEncoder.encode(value).byteLength : value.byteLength;

export const enforcePublishLimits = (files: readonly PublishFile[]): PublishError | null => {
  const diagnostics: { readonly path: string; readonly message: string }[] = [];
  if (files.length > PUBLISH_LIMITS.maxFiles) {
    diagnostics.push({
      path: "",
      message: `publish has ${files.length} files, exceeding the limit of ${PUBLISH_LIMITS.maxFiles}`,
    });
  }
  let total = 0;
  for (const file of files) {
    const size = byteLength(file.bytes);
    total += size;
    if (size > PUBLISH_LIMITS.maxFileBytes) {
      diagnostics.push({
        path: file.path,
        message: `file is ${size} bytes, exceeding the per-file limit of ${PUBLISH_LIMITS.maxFileBytes} bytes`,
      });
    }
  }
  if (total > PUBLISH_LIMITS.maxTotalBytes) {
    diagnostics.push({
      path: "",
      message: `publish total is ${total} bytes, exceeding the total limit of ${PUBLISH_LIMITS.maxTotalBytes} bytes`,
    });
  }
  return diagnostics.length === 0
    ? null
    : new PublishError({
        stage: "discover",
        message: `publish payload exceeds limits (${diagnostics.length} problem(s))`,
        diagnostics,
      });
};

const fileMap = (files: readonly PublishFile[]): ReadonlyMap<string, string> => {
  const out = new Map<string, string>();
  for (const file of files) out.set(file.path, textDecoder.decode(file.bytes));
  return out;
};

const sourceRef = (path: string, source: string): Effect.Effect<ModuleSourceRef> =>
  sha256Hex(source).pipe(Effect.map((sourceHash) => ({ path, sourceHash })));

const isPublishError = Predicate.isTagged("PublishError") as (
  value: unknown,
) => value is PublishError;

const decodeJson = Schema.decodeUnknownSync(Schema.UnknownFromJsonString);

const toPublishError = (
  stage: PublishError["stage"],
  path: string,
  cause: {
    readonly message: string;
    readonly diagnostics?: readonly { readonly path: string; readonly message: string }[];
  },
): PublishError =>
  new PublishError({
    stage,
    // oxlint-disable-next-line executor/no-unknown-error-message -- typed AppExecutorError conversion keeps its stable diagnostic message
    message: cause.message,
    diagnostics:
      cause.diagnostics && cause.diagnostics.length > 0
        ? cause.diagnostics
        : // oxlint-disable-next-line executor/no-unknown-error-message -- typed AppExecutorError conversion keeps its stable diagnostic message
          [{ path, message: cause.message }],
  });

const toolDescriptor = (input: {
  readonly collected: CollectedTool;
  readonly sourcePath: string;
  readonly bundleKey: string;
  readonly source: ModuleSourceRef;
}): ToolDescriptor => ({
  name: input.collected.toolName,
  sourcePath: input.sourcePath,
  bundleKey: input.bundleKey,
  source: input.source,
  description: input.collected.description,
  integrations: input.collected.integrations,
  inputSchema: input.collected.inputSchema,
  outputSchema: input.collected.outputSchema,
  annotations: input.collected.annotations,
});

export const publish = (
  deps: PublishDeps,
  input: PublishInput,
): Effect.Effect<PublishResult, PublishError> =>
  Effect.gen(function* () {
    const owner = input.owner ?? "org";
    const bundler =
      deps.bundler ??
      (yield* defaultBundleBackend().pipe(
        Effect.mapError((error) => toPublishError("bundle", "", error)),
      ));
    const limitError = enforcePublishLimits(input.files);
    if (limitError) return yield* limitError;
    const files = fileMap(input.files);
    const discovered = discover(files);
    if (isPublishError(discovered)) return yield* discovered;

    const existing = yield* deps.store.getDescriptorRecord(input.app).pipe(
      Effect.mapError(
        (cause) =>
          new PublishError({
            stage: "project",
            message: "failed to read existing app descriptor",
            diagnostics: [],
            cause,
          } as never),
      ),
    );
    if (existing?.sourceRef === input.sourceRef) {
      const descriptorBody = yield* deps.store.getBlob(existing.descriptorKey).pipe(
        Effect.mapError(
          () =>
            new PublishError({
              stage: "project",
              message: "failed to read existing descriptor blob",
              diagnostics: [],
            }),
        ),
      );
      if (descriptorBody) {
        return {
          descriptor: decodeJson(descriptorBody) as AppDescriptor,
          publishedTools: [],
          skipped: discovered.skipped,
          noop: true,
        };
      }
    }

    const staged: {
      readonly entry: string;
      readonly bundle: string;
      readonly collected: readonly CollectedTool[];
      readonly source: ModuleSourceRef;
    }[] = [];
    for (const artifact of discovered.tools) {
      const bundled = yield* bundleEntry({ files, entry: artifact.entry }, bundler).pipe(
        Effect.mapError((cause) => toPublishError("bundle", artifact.entry, cause)),
      );
      const collected = yield* deps.executor
        .collect(bundled.code, { fileSlug: artifact.name, sourcePath: artifact.entry })
        .pipe(Effect.mapError((cause) => toPublishError("collect", artifact.entry, cause)));
      const source = yield* sourceRef(artifact.entry, files.get(artifact.entry) ?? "");
      staged.push({
        entry: artifact.entry,
        bundle: bundled.code,
        collected: collected.tools,
        source,
      });
    }

    const tools: ToolDescriptor[] = [];
    for (const artifact of staged) {
      const bundleKey = yield* deps.store.putBlob(artifact.bundle, owner).pipe(
        Effect.mapError(
          () =>
            new PublishError({
              stage: "project",
              message: `failed to write bundle for ${artifact.entry}`,
              diagnostics: [{ path: artifact.entry, message: "bundle blob write failed" }],
            }),
        ),
      );
      for (const tool of artifact.collected) {
        tools.push(
          toolDescriptor({
            collected: tool,
            sourcePath: artifact.entry,
            bundleKey,
            source: artifact.source,
          }),
        );
      }
    }

    const descriptor: AppDescriptor = {
      version: DESCRIPTOR_VERSION,
      app: input.app,
      sourceRef: input.sourceRef,
      publishedAt: deps.now?.() ?? Date.now(),
      toolchain: bundler.toolchain(),
      tools,
      workflows: discovered.skipped.filter((item) => item.path.startsWith("workflows/")),
      ui: discovered.skipped.filter((item) => item.path.startsWith("ui/")),
      skills: discovered.skipped.filter((item) => item.path.startsWith("skills/")),
      skipped: discovered.skipped,
    };
    const descriptorBody = stableStringify(descriptor);
    const descriptorKey = yield* deps.store.putBlob(descriptorBody, owner).pipe(
      Effect.mapError(
        () =>
          new PublishError({
            stage: "project",
            message: "failed to write descriptor blob",
            diagnostics: [],
          }),
      ),
    );
    yield* deps.store
      .putPublished(descriptor, descriptorKey, owner, existing?.sourceRef ?? null)
      .pipe(
        Effect.mapError((cause) => {
          if (Predicate.isTagged("AppPublishConflictError")(cause)) {
            return new PublishError({
              stage: "project",
              message: `app "${input.app}" changed during publish`,
              diagnostics: [{ path: "", message: "publish sourceRef changed during publish" }],
            });
          }
          return new PublishError({
            stage: "project",
            message: "failed to persist app publication",
            diagnostics: [],
          });
        }),
      );
    return {
      descriptor,
      publishedTools: descriptor.tools.map((tool) => tool.name),
      skipped: discovered.skipped,
      noop: false,
    };
  });