import {
  INVALID_SPAN_CONTEXT,
  SpanKind,
  SpanStatusCode,
  trace,
  type Attributes,
  type Span,
} from '@opentelemetry/api';

type PrimitiveAttribute = string | number | boolean | null | undefined;

type TraceAttributes = Record<string, PrimitiveAttribute>;

const NOOP_SPAN: Span = {
  spanContext: () => INVALID_SPAN_CONTEXT,
  setAttribute: () => NOOP_SPAN,
  setAttributes: () => NOOP_SPAN,
  addEvent: () => NOOP_SPAN,
  addLink: () => NOOP_SPAN,
  addLinks: () => NOOP_SPAN,
  setStatus: () => NOOP_SPAN,
  updateName: () => NOOP_SPAN,
  end: () => undefined,
  isRecording: () => false,
  recordException: () => undefined,
};

function discardTelemetryResult(invoke: () => unknown): void {
  try {
    const result = invoke();
    if (
      result === null ||
      (typeof result !== 'object' && typeof result !== 'function')
    ) {
      return;
    }
    let then: unknown;
    try {
      then = Reflect.get(result, 'then');
    } catch {
      return;
    }
    if (typeof then === 'function') {
      void Promise.resolve(result).catch(() => undefined);
    }
  } catch {}
}

function nonBlockingSpan(span: Span): Span {
  const safeSpan: Span = {
    spanContext() {
      try {
        return span.spanContext();
      } catch {
        return INVALID_SPAN_CONTEXT;
      }
    },
    setAttribute(key, value) {
      discardTelemetryResult(() => span.setAttribute(key, value));
      return safeSpan;
    },
    setAttributes(attributes) {
      discardTelemetryResult(() => span.setAttributes(attributes));
      return safeSpan;
    },
    addEvent(name, attributesOrStartTime, startTime) {
      discardTelemetryResult(() =>
        span.addEvent(name, attributesOrStartTime, startTime),
      );
      return safeSpan;
    },
    addLink(link) {
      discardTelemetryResult(() => span.addLink(link));
      return safeSpan;
    },
    addLinks(links) {
      discardTelemetryResult(() => span.addLinks(links));
      return safeSpan;
    },
    setStatus(status) {
      discardTelemetryResult(() => span.setStatus(status));
      return safeSpan;
    },
    updateName(name) {
      discardTelemetryResult(() => span.updateName(name));
      return safeSpan;
    },
    end(endTime) {
      discardTelemetryResult(() => span.end(endTime));
    },
    isRecording() {
      try {
        return span.isRecording();
      } catch {
        return false;
      }
    },
    recordException(exception, time) {
      discardTelemetryResult(() => span.recordException(exception, time));
    },
  };
  return safeSpan;
}

function normalizeAttributes(
  attributes: TraceAttributes | undefined,
): Attributes | undefined {
  if (!attributes) {
    return undefined;
  }

  const normalized: Attributes = {};
  for (const [key, value] of Object.entries(attributes)) {
    if (value === undefined || value === null) {
      continue;
    }
    if (
      typeof value === 'string' ||
      typeof value === 'number' ||
      typeof value === 'boolean'
    ) {
      normalized[key] = value;
    }
  }
  return Object.keys(normalized).length > 0 ? normalized : undefined;
}

function recordError(span: Span, error: unknown): void {
  if (error instanceof Error) {
    span.recordException(error);
    span.setStatus({
      code: SpanStatusCode.ERROR,
      message: error.message,
    });
    return;
  }

  const message = String(error);
  span.recordException({ name: 'Error', message });
  span.setStatus({
    code: SpanStatusCode.ERROR,
    message,
  });
}

export async function withActiveSpan<T>(
  name: string,
  options: {
    tracer?: string;
    kind?: SpanKind;
    attributes?: TraceAttributes;
  },
  fn: (span: Span) => Promise<T> | T,
): Promise<T> {
  let operationPromise: Promise<T> | null = null;
  const runOperation = async (span: Span): Promise<T> => {
    const safeSpan = nonBlockingSpan(span);
    try {
      const result = await fn(safeSpan);
      safeSpan.setStatus({ code: SpanStatusCode.OK });
      return result;
    } catch (error) {
      try {
        recordError(safeSpan, error);
      } catch {
        // Error telemetry must not replace the operation's real error.
      }
      throw error;
    } finally {
      safeSpan.end();
    }
  };
  const startOperation = (span: Span): Promise<T> => {
    if (operationPromise) return operationPromise;
    let resolveOperation!: (value: T | PromiseLike<T>) => void;
    let rejectOperation!: (reason?: unknown) => void;
    operationPromise = new Promise<T>((resolve, reject) => {
      resolveOperation = resolve;
      rejectOperation = reject;
    });
    void runOperation(span).then(resolveOperation, rejectOperation);
    return operationPromise;
  };

  let tracerResult: unknown;
  try {
    const tracer = trace.getTracer(options.tracer ?? 'deepline');
    tracerResult = tracer.startActiveSpan(
      name,
      {
        kind: options.kind,
        attributes: normalizeAttributes(options.attributes),
      },
      (span) => startOperation(span),
    );
  } catch {}

  // A non-conforming exporter may return work unrelated to the callback.
  // Drain its rejection without awaiting it; only execution owns latency and
  // the returned success/failure contract.
  discardTelemetryResult(() => tracerResult);

  // A broken tracer may return without invoking the callback. Execution is
  // authoritative, so run it once without telemetry in that case.
  return await startOperation(NOOP_SPAN);
}

export function setSpanAttributes(
  span: Span,
  attributes: TraceAttributes,
): void {
  try {
    const normalized = normalizeAttributes(attributes);
    if (normalized) {
      discardTelemetryResult(() => span.setAttributes(normalized));
    }
  } catch {}
}