import { resourceFromAttributes } from '@opentelemetry/resources';
import {
  W3CTraceContextPropagator,
  type ExportResult,
} from '@opentelemetry/core';
import {
  BatchSpanProcessor,
  type ReadableSpan,
} from '@opentelemetry/sdk-trace-base';
import * as SemanticAttributes from '@opentelemetry/semantic-conventions';
import { registerInstrumentations } from '@opentelemetry/instrumentation';
import {
  SessionType,
  SessionRecorderSdk,
  SessionRecorderIdGenerator,
  SessionRecorderBrowserTraceExporter,
  ATTR_MULTIPLAYER_SESSION_ID,
  MULTIPLAYER_TRACE_CLIENT_ID_LENGTH,
  SessionRecorderTraceIdRatioBasedSampler,
} from '@multiplayer-app/session-recorder-common';
import { type TracerReactNativeConfig } from '../types';
import { getInstrumentations } from './instrumentations';
import { getExporterEndpoint } from './helpers';

import { getPlatformAttributes } from '../utils/platform';
import { WebTracerProvider } from '@opentelemetry/sdk-trace-web';
import { CrashBufferService } from '../services/crashBuffer.service';
import { CrashBufferSpanProcessor } from './CrashBufferSpanProcessor';

const clientIdGenerator = SessionRecorderSdk.getIdGenerator(
  MULTIPLAYER_TRACE_CLIENT_ID_LENGTH
);

export class TracerReactNativeSDK {
  clientId = '';
  private tracerProvider?: WebTracerProvider;
  private config?: TracerReactNativeConfig;

  private sessionId = '';
  private idGenerator?: SessionRecorderIdGenerator;
  private exporter?: SessionRecorderBrowserTraceExporter;
  private globalErrorHandlerRegistered = false;
  private crashBuffer?: CrashBufferService;

  constructor() {}

  private _setSessionId(
    sessionId: string,
    sessionType: SessionType = SessionType.MANUAL
  ) {
    this.sessionId = sessionId;

    if (!this.idGenerator) {
      throw new Error('Id generator not initialized');
    }

    this.idGenerator.setSessionId(sessionId, sessionType, this.clientId);
  }

  init(options: TracerReactNativeConfig): void {
    this.config = options;
    this.clientId = clientIdGenerator();

    const { application, version, environment } = this.config;

    this.idGenerator = new SessionRecorderIdGenerator();

    this._setSessionId('', SessionType.SESSION_CACHE);

    this.exporter = new SessionRecorderBrowserTraceExporter({
      apiKey: options.apiKey,
      url: getExporterEndpoint(options.exporterEndpoint),
    });

    const resourceAttributes = resourceFromAttributes({
      [SemanticAttributes.SEMRESATTRS_SERVICE_NAME]: application,
      [SemanticAttributes.SEMRESATTRS_SERVICE_VERSION]: version,
      [SemanticAttributes.SEMRESATTRS_DEPLOYMENT_ENVIRONMENT]: environment,
      ...getPlatformAttributes(),
    });

    SessionRecorderSdk.setResourceAttributes(resourceAttributes.attributes);

    this.tracerProvider = new WebTracerProvider({
      resource: resourceAttributes,
      idGenerator: this.idGenerator,
      sampler: new SessionRecorderTraceIdRatioBasedSampler(
        this.config.sampleTraceRatio
      ),
      spanProcessors: [
        this._getSpanSessionIdProcessor(),
        new BatchSpanProcessor(this.exporter),
        new CrashBufferSpanProcessor(
          this.crashBuffer,
          this.exporter.serializeSpan
        ),
      ],
    });

    this.tracerProvider.register({
      propagator: new W3CTraceContextPropagator(),
    });

    // Register instrumentations
    registerInstrumentations({
      tracerProvider: this.tracerProvider,
      instrumentations: getInstrumentations(this.config),
    });

    this._registerGlobalErrorHandlers();
  }

  setCrashBuffer(
    crashBuffer: CrashBufferService | undefined,
    windowMs?: number
  ): void {
    this.crashBuffer = crashBuffer;
    if (
      crashBuffer &&
      typeof windowMs === 'number' &&
      Number.isFinite(windowMs)
    ) {
      crashBuffer.setDefaultWindowMs(windowMs);
    }
  }

  async exportTraces(
    spans: ReadableSpan[]
  ): Promise<ExportResult | undefined | void> {
    if (!this.exporter) {
      throw new Error('Trace exporter not initialized');
    }
    if (!spans || spans.length === 0) {
      return Promise.resolve();
    }

    const readableSpans = spans.map((s: any) =>
      TracerReactNativeSDK._toReadableSpanLike(s)
    );

    return new Promise((resolve) => {
      this.exporter?.exportBuffer(readableSpans, (result) => {
        resolve(result);
      });
    });
  }

  start(sessionId: string, sessionType: SessionType): void {
    if (!this.tracerProvider) {
      throw new Error(
        'Configuration not initialized. Call init() before start().'
      );
    }

    this._setSessionId(sessionId, sessionType);
  }

  stop(): void {
    if (!this.tracerProvider) {
      throw new Error(
        'Configuration not initialized. Call init() before start().'
      );
    }

    this._setSessionId('', SessionType.SESSION_CACHE);
  }

  setApiKey(apiKey: string): void {
    if (!this.exporter) {
      throw new Error(
        'Configuration not initialized. Call init() before setApiKey().'
      );
    }

    this.exporter.setApiKey(apiKey);
  }

  /**
   * Capture an exception as an error span/event.
   * If there is an active span, the exception will be recorded on it.
   * Otherwise, a short-lived span will be created to hold the exception event.
   */
  captureException(error: Error, errorInfo?: Record<string, any>): void {
    if (!error) return;
    SessionRecorderSdk.captureException(error, errorInfo);
  }

  private _getSpanSessionIdProcessor() {
    return {
      onStart: (span: any) => {
        if (this.sessionId) {
          span.setAttribute(ATTR_MULTIPLAYER_SESSION_ID, this.sessionId);
        }
      },
      onEnd: () => {},
      shutdown: () => Promise.resolve(),
      forceFlush: () => Promise.resolve(),
    };
  }

  private _registerGlobalErrorHandlers(): void {
    if (this.globalErrorHandlerRegistered) return;

    // React Native global error handler

    const ErrorUtilsRef: any = (global as any).ErrorUtils;
    if (ErrorUtilsRef && typeof ErrorUtilsRef.setGlobalHandler === 'function') {
      const previous = ErrorUtilsRef.getGlobalHandler?.();
      ErrorUtilsRef.setGlobalHandler((error: any, isFatal?: boolean) => {
        try {
          const err =
            error instanceof Error
              ? error
              : new Error(String(error?.message || error));
          this.captureException(err);
        } finally {
          if (typeof previous === 'function') {
            try {
              previous(error, isFatal);
            } catch (_e) {
              /* ignore */
            }
          }
        }
      });
      this.globalErrorHandlerRegistered = true;
    }
  }

  private static _toReadableSpanLike(span: any): ReadableSpan {
    if (
      span &&
      typeof span.spanContext === 'function' &&
      span.instrumentationScope
    ) {
      return span as ReadableSpan;
    }

    const spanContext =
      typeof span?.spanContext === 'function'
        ? span.spanContext()
        : span?._spanContext;
    const normalizedCtx =
      spanContext ||
      ({
        traceId: span?.traceId,
        spanId: span?.spanId,
        traceFlags: span?.traceFlags,
        traceState: span?.traceState,
      } as any);

    const instrumentationScope =
      span?.instrumentationScope ||
      span?.instrumentationLibrary ||
      ({
        name: 'multiplayer-buffer',
        version: undefined,
        schemaUrl: undefined,
      } as any);

    const normalizedScope = {
      name: instrumentationScope?.name || 'multiplayer-buffer',
      version: instrumentationScope?.version,
      schemaUrl: instrumentationScope?.schemaUrl,
    };

    const resource = span?.resource || {
      attributes: {},
      asyncAttributesPending: false,
    };
    const parentSpanId = span?.parentSpanId;

    return {
      name: span?.name || '',
      kind: span?.kind,
      spanContext: () => normalizedCtx,
      parentSpanContext: parentSpanId
        ? ({
            traceId: normalizedCtx?.traceId,
            spanId: parentSpanId,
            traceFlags: normalizedCtx?.traceFlags,
            traceState: normalizedCtx?.traceState,
          } as any)
        : undefined,
      startTime: span?.startTime,
      endTime: span?.endTime ?? span?.startTime,
      duration: span?.duration,
      status: span?.status,
      attributes: span?.attributes || {},
      links: span?.links || [],
      events: span?.events || [],
      ended: typeof span?.ended === 'boolean' ? span.ended : true,
      droppedAttributesCount: span?.droppedAttributesCount || 0,
      droppedEventsCount: span?.droppedEventsCount || 0,
      droppedLinksCount: span?.droppedLinksCount || 0,
      resource,
      instrumentationScope: normalizedScope as any,
    } as any;
  }
}