import { Effect, Option } from "effect";

import { OpenApiExtractionError } from "./errors";
import type { ParsedDocument } from "./parse";
import {
  DocResolver,
  preferredContent,
  type OperationObject,
  type ParameterObject,
  type PathItemObject,
  type RequestBodyObject,
  type ResponseObject,
} from "./openapi-utils";
import {
  ExtractedOperation,
  ExtractionResult,
  type HttpMethod,
  OperationId,
  OperationParameter,
  OperationRequestBody,
  type ParameterLocation,
  ServerInfo,
} from "./types";

// ---------------------------------------------------------------------------
// Constants
// ---------------------------------------------------------------------------

const HTTP_METHODS: readonly HttpMethod[] = [
  "get", "put", "post", "delete", "patch", "head", "options", "trace",
];

const VALID_PARAM_LOCATIONS = new Set<string>(["path", "query", "header", "cookie"]);

// ---------------------------------------------------------------------------
// Parameter extraction
// ---------------------------------------------------------------------------

const extractParameters = (
  pathItem: PathItemObject,
  operation: OperationObject,
  r: DocResolver,
): OperationParameter[] => {
  const merged = new Map<string, ParameterObject>();

  for (const raw of pathItem.parameters ?? []) {
    const p = r.resolve<ParameterObject>(raw);
    if (!p) continue;
    merged.set(`${p.in}:${p.name}`, p);
  }
  for (const raw of operation.parameters ?? []) {
    const p = r.resolve<ParameterObject>(raw);
    if (!p) continue;
    merged.set(`${p.in}:${p.name}`, p);
  }

  return [...merged.values()]
    .filter((p) => VALID_PARAM_LOCATIONS.has(p.in))
    .map(
      (p) =>
        new OperationParameter({
          name: p.name,
          location: p.in as ParameterLocation,
          required: p.in === "path" ? true : p.required === true,
          schema: Option.fromNullable(p.schema),
          style: Option.fromNullable(p.style),
          explode: Option.fromNullable(p.explode),
          allowReserved: Option.fromNullable(
            "allowReserved" in p ? p.allowReserved : undefined,
          ),
          description: Option.fromNullable(p.description),
        }),
    );
};

// ---------------------------------------------------------------------------
// Request body extraction
// ---------------------------------------------------------------------------

const extractRequestBody = (
  operation: OperationObject,
  r: DocResolver,
): OperationRequestBody | undefined => {
  if (!operation.requestBody) return undefined;

  const body = r.resolve<RequestBodyObject>(operation.requestBody);
  if (!body) return undefined;

  const content = preferredContent(body.content);
  if (!content) return undefined;

  return new OperationRequestBody({
    required: body.required === true,
    contentType: content.mediaType,
    schema: Option.fromNullable(content.media.schema),
  });
};

// ---------------------------------------------------------------------------
// Response schema extraction
// ---------------------------------------------------------------------------

const extractOutputSchema = (
  operation: OperationObject,
  r: DocResolver,
): unknown | undefined => {
  if (!operation.responses) return undefined;

  const entries = Object.entries(operation.responses);
  const preferred = [
    ...entries.filter(([s]) => /^2\d\d$/.test(s)).sort(([a], [b]) => a.localeCompare(b)),
    ...entries.filter(([s]) => s === "default"),
  ];

  for (const [, ref] of preferred) {
    const resp = r.resolve<ResponseObject>(ref);
    if (!resp) continue;
    const content = preferredContent(resp.content);
    if (content?.media.schema) return content.media.schema;
  }

  return undefined;
};

// ---------------------------------------------------------------------------
// Input schema builder
// ---------------------------------------------------------------------------

const buildInputSchema = (
  parameters: readonly OperationParameter[],
  requestBody: OperationRequestBody | undefined,
): Record<string, unknown> | undefined => {
  const properties: Record<string, unknown> = {};
  const required: string[] = [];

  for (const param of parameters) {
    properties[param.name] = Option.getOrElse(param.schema, () => ({ type: "string" }));
    if (param.required) required.push(param.name);
  }

  if (requestBody) {
    properties.body = Option.getOrElse(requestBody.schema, () => ({ type: "object" }));
    if (requestBody.required) required.push("body");
  }

  if (Object.keys(properties).length === 0) return undefined;

  return {
    type: "object",
    properties,
    ...(required.length > 0 ? { required } : {}),
    additionalProperties: false,
  };
};

// ---------------------------------------------------------------------------
// Operation ID derivation
// ---------------------------------------------------------------------------

const deriveOperationId = (
  method: HttpMethod,
  pathTemplate: string,
  operation: OperationObject,
): string =>
  operation.operationId ??
  (`${method}_${pathTemplate.replace(/[^a-zA-Z0-9]+/g, "_")}`.replace(
    /^_+|_+$/g,
    "",
  ) || `${method}_operation`);

// ---------------------------------------------------------------------------
// Server extraction
// ---------------------------------------------------------------------------

const extractServers = (doc: ParsedDocument): ServerInfo[] =>
  (doc.servers ?? []).flatMap((server) => {
    if (!server.url) return [];
    const vars = server.variables
      ? Object.fromEntries(
          Object.entries(server.variables).flatMap(([name, v]) =>
            v.default ? [[name, v.default]] : [],
          ),
        )
      : undefined;
    return [
      new ServerInfo({
        url: server.url,
        variables:
          vars && Object.keys(vars).length > 0
            ? Option.some(vars)
            : Option.none(),
      }),
    ];
  });

// ---------------------------------------------------------------------------
// Main extraction
// ---------------------------------------------------------------------------

/** Extract all operations from a bundled OpenAPI 3.x document */
export const extract = Effect.fn("OpenApi.extract")(function* (
  doc: ParsedDocument,
) {
  const paths = doc.paths;
  if (!paths) {
    return yield* new OpenApiExtractionError({
      message: "OpenAPI document has no paths defined",
    });
  }

  const r = new DocResolver(doc);
  const operations: ExtractedOperation[] = [];

  for (const [pathTemplate, pathItem] of Object.entries(paths).sort(
    ([a], [b]) => a.localeCompare(b),
  )) {
    if (!pathItem) continue;

    for (const method of HTTP_METHODS) {
      const operation = pathItem[method];
      if (!operation) continue;

      const parameters = extractParameters(pathItem, operation, r);
      const requestBody = extractRequestBody(operation, r);
      const inputSchema = buildInputSchema(parameters, requestBody);
      const outputSchema = extractOutputSchema(operation, r);
      const tags = (operation.tags ?? []).filter((t) => t.trim().length > 0);

      operations.push(
        new ExtractedOperation({
          operationId: OperationId.make(
            deriveOperationId(method, pathTemplate, operation),
          ),
          method,
          pathTemplate,
          summary: Option.fromNullable(operation.summary),
          description: Option.fromNullable(operation.description),
          tags,
          parameters,
          requestBody: Option.fromNullable(requestBody),
          inputSchema: Option.fromNullable(inputSchema),
          outputSchema: Option.fromNullable(outputSchema),
          deprecated: operation.deprecated === true,
        }),
      );
    }
  }

  return new ExtractionResult({
    title: Option.fromNullable(doc.info?.title),
    version: Option.fromNullable(doc.info?.version),
    servers: extractServers(doc),
    operations,
  });
});