import { Platform } from 'react-native';
import { EventType } from '@rrweb/types';
import type {
  CrashBufferEventMap,
  CrashBufferEventName,
  CrashBufferErrorSpanAppendedEvent,
  CrashBuffer,
  CrashBufferRrwebEventPayload,
  CrashBufferOtelSpanPayload,
  CrashBufferOtelSpanBatchPayload,
  CrashBufferSnapshot,
} from '@multiplayer-app/session-recorder-common';
import { SpanStatusCode } from '@opentelemetry/api';

// Safe import for AsyncStorage with web fallback
let AsyncStorage: any = null;
const isWeb = Platform.OS === 'web';

if (!isWeb) {
  try {
    AsyncStorage = require('@react-native-async-storage/async-storage').default;
  } catch (_error) {
    AsyncStorage = null;
  }
} else {
  AsyncStorage = {
    getItem: (_key: string) => Promise.resolve(null),
    setItem: (_key: string, _value: string) => Promise.resolve(undefined),
    removeItem: (_key: string) => Promise.resolve(undefined),
    multiRemove: (_keys: string[]) => Promise.resolve(undefined),
    multiGet: (_keys: string[]) => Promise.resolve([]),
    multiSet: (_pairs: Array<[string, string]>) => Promise.resolve(undefined),
  };
}

type RecordKind = 'rrweb' | 'span';

type IndexEntry = {
  id: string;
  ts: number;
  kind: RecordKind;
};

const INDEX_KEY = 'mp_crash_buffer_index_v1';
const ATTRS_KEY = 'mp_crash_buffer_attrs_v1';
const RECORD_PREFIX = 'mp_crash_buffer_rec_v1:';

const randomId = (): string =>
  `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;

export class CrashBufferService implements CrashBuffer {
  private static instance: CrashBufferService | null = null;

  private index: IndexEntry[] = [];
  private indexLoaded = false;
  private lastPruneAt = 0;
  private opChain: Promise<any> = Promise.resolve();
  private defaultWindowMs: number = 0.5 * 60 * 1000;
  private lastSeenEventTs: number = 0;

  private listeners = new Map<
    CrashBufferEventName,
    Set<(payload: CrashBufferEventMap[CrashBufferEventName]) => void>
  >();

  static getInstance(): CrashBufferService {
    if (!CrashBufferService.instance) {
      CrashBufferService.instance = new CrashBufferService();
    }
    return CrashBufferService.instance;
  }

  private enqueue<T>(fn: () => Promise<T>): Promise<T> {
    const next = this.opChain.then(fn, fn);
    // Preserve chain, but don't leak rejections.
    this.opChain = next.then(
      () => undefined,
      () => undefined
    );
    return next;
  }

  private async ensureIndexLoaded(): Promise<void> {
    if (this.indexLoaded) return;
    if (!AsyncStorage) {
      this.indexLoaded = true;
      this.index = [];
      return;
    }
    try {
      const raw = await AsyncStorage.getItem(INDEX_KEY);
      this.index = raw ? JSON.parse(raw) : [];
    } catch (_e) {
      this.index = [];
    } finally {
      this.indexLoaded = true;
    }
  }

  async setAttrs(attrs: any): Promise<void> {
    return this.enqueue(async () => {
      if (!AsyncStorage) return;
      try {
        await AsyncStorage.setItem(ATTRS_KEY, JSON.stringify(attrs || null));
      } catch (_e) {
        // best-effort
      }
    });
  }

  async appendEvent(
    payload: CrashBufferRrwebEventPayload,
    windowMs?: number
  ): Promise<void> {
    const ts = payload?.ts ?? Date.now();
    this.lastSeenEventTs = Math.max(this.lastSeenEventTs, ts);

    const rawEventType =
      (payload as any)?.event?.eventType ?? (payload as any)?.event?.type;
    const isFullSnapshot =
      Boolean(payload.isFullSnapshot) ||
      rawEventType === EventType.FullSnapshot;

    const record: CrashBufferRrwebEventPayload = {
      ...payload,
      ts,
      isFullSnapshot,
    };

    return this.appendRecord(
      'rrweb',
      record.ts,
      record,
      windowMs ?? this.defaultWindowMs
    );
  }

  async appendSpans(
    payload: CrashBufferOtelSpanBatchPayload,
    windowMs?: number
  ): Promise<void> {
    if (!payload.length) return;
    const effectiveWindowMs = windowMs ?? this.defaultWindowMs;
    return this.enqueue(async () => {
      if (!AsyncStorage) return;
      await this.ensureIndexLoaded();

      const pairs: Array<[string, string]> = [];
      let errorEvent: CrashBufferErrorSpanAppendedEvent | null = null;
      for (const p of payload) {
        const id = randomId();
        const key = `${RECORD_PREFIX}${id}`;
        const entry: IndexEntry = { id, ts: p.ts, kind: 'span' };
        this.index.push(entry);
        pairs.push([key, JSON.stringify(p)]);
        if (!errorEvent && p?.span?.status?.code === SpanStatusCode.ERROR) {
          errorEvent = { ts: p.ts, span: p.span };
        }
      }

      try {
        await AsyncStorage.multiSet(pairs);
        await AsyncStorage.setItem(INDEX_KEY, JSON.stringify(this.index));
      } catch (_e) {
        // best-effort
      }

      this.pruneSoon(effectiveWindowMs);

      if (errorEvent) {
        this._emit('error-span-appended', errorEvent);
      }
    });
  }

  setDefaultWindowMs(windowMs: number): void {
    this.defaultWindowMs = Math.max(10_000, windowMs || 0.5 * 60 * 1000);
  }

  on<E extends CrashBufferEventName>(
    event: E,
    listener: (payload: CrashBufferEventMap[E]) => void
  ): () => void {
    const set = this.listeners.get(event) || new Set();
    set.add(listener as any);
    this.listeners.set(event, set as any);
    return () => this.off(event, listener as any);
  }

  off<E extends CrashBufferEventName>(
    event: E,
    listener: (payload: CrashBufferEventMap[E]) => void
  ): void {
    const set = this.listeners.get(event);
    if (!set) return;
    set.delete(listener as any);
    if (set.size === 0) this.listeners.delete(event);
  }

  private _emit<E extends CrashBufferEventName>(
    event: E,
    payload: CrashBufferEventMap[E]
  ): void {
    const set = this.listeners.get(event);
    if (!set || set.size === 0) return;
    for (const fn of Array.from(set)) {
      try {
        (fn as any)(payload);
      } catch (_e) {
        // never throw into app code
      }
    }
  }

  private async appendRecord(
    kind: RecordKind,
    ts: number,
    payload: any,
    windowMs: number
  ): Promise<void> {
    return this.enqueue(async () => {
      if (!AsyncStorage) return;
      await this.ensureIndexLoaded();

      const id = randomId();
      const key = `${RECORD_PREFIX}${id}`;
      const entry: IndexEntry = { id, ts, kind };
      this.index.push(entry);

      try {
        await AsyncStorage.setItem(key, JSON.stringify(payload));
        await AsyncStorage.setItem(INDEX_KEY, JSON.stringify(this.index));
      } catch (_e) {
        // best-effort
      }

      this.pruneSoon(windowMs);
    });
  }

  private pruneSoon(windowMs: number) {
    const now = Date.now();
    if (now - this.lastPruneAt < 2000) return;
    this.lastPruneAt = now;
    const cutoff = Math.max(0, now - windowMs);
    void this.pruneOlderThan(cutoff);
  }

  async pruneOlderThan(cutoffTs: number): Promise<void> {
    return this.enqueue(async () => {
      if (!AsyncStorage) return;
      await this.ensureIndexLoaded();
      const toRemove = this.index.filter((e) => e.ts < cutoffTs);
      if (toRemove.length === 0) return;

      const removeKeys = toRemove.map((e) => `${RECORD_PREFIX}${e.id}`);
      this.index = this.index.filter((e) => e.ts >= cutoffTs);

      try {
        await AsyncStorage.multiRemove(removeKeys);
        await AsyncStorage.setItem(INDEX_KEY, JSON.stringify(this.index));
      } catch (_e) {
        // best-effort
      }
    });
  }

  async snapshot(
    windowMs?: number,
    now: number = Date.now()
  ): Promise<CrashBufferSnapshot> {
    return this.enqueue(async () => {
      await this.ensureIndexLoaded();
      const effectiveWindowMs = windowMs ?? this.defaultWindowMs;
      const toTs = now;
      const fromTs = Math.max(0, toTs - effectiveWindowMs);
      const entries = this.index.filter((e) => e.ts >= fromTs && e.ts <= toTs);
      const keys = entries.map((e) => `${RECORD_PREFIX}${e.id}`);

      let pairs: Array<[string, string | null]> = [];
      try {
        pairs = AsyncStorage ? await AsyncStorage.multiGet(keys) : [];
      } catch (_e) {
        pairs = [];
      }

      const byKey = new Map<string, any>();
      for (const [k, v] of pairs) {
        if (!v) continue;
        try {
          byKey.set(k, JSON.parse(v));
        } catch (_e) {
          // ignore
        }
      }

      const allEvents: CrashBufferRrwebEventPayload[] = [];
      const allSpans: CrashBufferOtelSpanPayload[] = [];

      for (const e of entries.sort((a, b) => a.ts - b.ts)) {
        const key = `${RECORD_PREFIX}${e.id}`;
        const payload = byKey.get(key);
        if (!payload) continue;
        if (e.kind === 'rrweb') allEvents.push(payload);
        if (e.kind === 'span') allSpans.push(payload);
      }

      // Mirror browser semantics:
      // - Ensure the rrweb stream starts at Meta -> FullSnapshot (or is empty).
      // - Only include spans from the replayable window onward.
      const eventsSorted = allEvents.slice().sort((a, b) => a.ts - b.ts);
      const firstSnapshotIdx = eventsSorted.findIndex((e) => {
        const t = (e as any)?.event?.eventType ?? (e as any)?.event?.type;
        return t === EventType.FullSnapshot;
      });

      if (firstSnapshotIdx < 0) {
        return {
          events: [],
          spans: [],
          startedAt: fromTs,
          stoppedAt: toTs,
        };
      }

      let startIdx = firstSnapshotIdx;
      for (let i = firstSnapshotIdx - 1; i >= 0; i--) {
        const t =
          (eventsSorted[i] as any)?.event?.eventType ??
          (eventsSorted[i] as any)?.event?.type;
        if (t === EventType.Meta) {
          startIdx = i;
          break;
        }
      }

      const rrwebEvents = eventsSorted.slice(startIdx);
      const firstEvent = rrwebEvents[0];
      const replayStartedAt =
        typeof firstEvent?.ts === 'number' ? firstEvent.ts : fromTs;

      const otelSpans = allSpans
        .filter((s) => typeof s?.ts === 'number' && s.ts >= replayStartedAt)
        .sort((a, b) => a.ts - b.ts);

      return {
        spans: otelSpans,
        events: rrwebEvents,
        stoppedAt: toTs,
        startedAt: replayStartedAt,
      };
    });
  }

  async clear(): Promise<void> {
    return this.enqueue(async () => {
      if (!AsyncStorage) return;
      await this.ensureIndexLoaded();
      const keys = this.index.map((e) => `${RECORD_PREFIX}${e.id}`);
      this.index = [];
      this.lastSeenEventTs = 0;
      try {
        await AsyncStorage.multiRemove([INDEX_KEY, ATTRS_KEY, ...keys]);
      } catch (_e) {
        // best-effort
      }
    });
  }
}