import { HttpApiBuilder } from "effect/unstable/httpapi";
import { Effect } from "effect";
import {
  sanitizeArtifactPreviewMarkup,
  type Artifact,
  type ArtifactSummary,
} from "@executor-js/sdk";

import { ExecutorApi } from "../api";
import { ArtifactUsageObserver, ExecutorService, type ArtifactUsageAction } from "../services";
import { capture } from "@executor-js/api";

// Best-effort usage observation (see `ArtifactUsageObserver`): notified after
// the operation succeeded, failures swallowed, so analytics can never fail or
// slow an artifact request.
const notifyArtifactUsage = (action: ArtifactUsageAction) =>
  Effect.flatMap(Effect.service(ArtifactUsageObserver), (observer) =>
    observer ? observer(action).pipe(Effect.ignoreCause({ log: false })) : Effect.void,
  );

const summaryToResponse = (a: ArtifactSummary) => ({
  id: a.id,
  owner: a.owner,
  title: a.title,
  description: a.description,
  preview: a.preview,
  createdAt: a.createdAt.getTime(),
  updatedAt: a.updatedAt.getTime(),
});

const artifactToResponse = (a: Artifact) => ({
  ...summaryToResponse(a),
  code: a.code,
  bindings: a.bindings,
});

export const ArtifactsHandlers = HttpApiBuilder.group(ExecutorApi, "artifacts", (handlers) =>
  handlers
    .handle("list", () =>
      capture(
        Effect.gen(function* () {
          const executor = yield* ExecutorService;
          const artifacts = yield* executor.artifacts.list();
          return artifacts.map(summaryToResponse);
        }),
      ),
    )
    .handle("get", ({ params: path }) =>
      capture(
        Effect.gen(function* () {
          const executor = yield* ExecutorService;
          const artifact = yield* executor.artifacts.get(path.artifactId);
          yield* notifyArtifactUsage("viewed");
          return artifactToResponse(artifact);
        }),
      ),
    )
    .handle("save", ({ payload }) =>
      capture(
        Effect.gen(function* () {
          const executor = yield* ExecutorService;
          const saved = yield* executor.artifacts.save({
            id: payload.id,
            title: payload.title,
            description: payload.description,
            code: payload.code,
            bindings: payload.bindings,
          });
          yield* notifyArtifactUsage(payload.id === undefined ? "created" : "updated");
          return artifactToResponse(saved);
        }),
      ),
    )
    .handle("rename", ({ params: path, payload }) =>
      capture(
        Effect.gen(function* () {
          const executor = yield* ExecutorService;
          const renamed = yield* executor.artifacts.rename({
            id: path.artifactId,
            title: payload.title,
          });
          yield* notifyArtifactUsage("updated");
          return artifactToResponse(renamed);
        }),
      ),
    )
    .handle("remove", ({ params: path }) =>
      capture(
        Effect.gen(function* () {
          const executor = yield* ExecutorService;
          yield* executor.artifacts.remove({ id: path.artifactId });
          yield* notifyArtifactUsage("deleted");
          return { removed: true };
        }),
      ),
    )
    .handle("setPreview", ({ params: path, payload }) =>
      capture(
        Effect.gen(function* () {
          // This markup came from a BROWSER, not from this server's own
          // sandbox, so it is sanitized here before it is stored — through the
          // same allowlist the create-time preview goes through, which is what
          // makes the console safe to render either kind identically.
          //
          // A payload that sanitizes to nothing is reported as not stored
          // rather than as an error: the caller is a viewer who merely opened
          // an artifact, and the card simply keeps its layout preview.
          const sanitized = sanitizeArtifactPreviewMarkup(payload.preview);
          if (sanitized === null) return { stored: false };
          const executor = yield* ExecutorService;
          yield* executor.artifacts.setPreview({
            id: path.artifactId,
            preview: sanitized,
          });
          return { stored: true };
        }),
      ),
    ),
);