import { Dimensions, Platform } from 'react-native';
import { trace, SpanStatusCode, type Span } from '@opentelemetry/api';
import { logger } from '../utils';
import {
  type GestureEvent,
  type RecorderConfig,
  type EventRecorder,
} from '../types';
import {
  MouseInteractions,
  type eventWithTime,
  EventType,
  IncrementalSource,
} from '@rrweb/types';
import {
  type NativeGestureEvent,
  SessionRecorderNative,
  gestureEventEmitter,
} from '../native';
// Force TypeScript recompilation

export class GestureRecorder implements EventRecorder {
  // @ts-ignore
  private config?: RecorderConfig;
  private isRecording = false;
  private events: GestureEvent[] = [];
  private screenDimensions: { width: number; height: number } | null = null;
  private lastGestureTime: number = 0;
  private gestureThrottleMs: number = 50; // Throttle gestures to avoid spam
  private lastTouchTime: number = 0;
  private touchThrottleMs: number = 100; // Throttle touch events to max 10 per second
  private eventRecorder?: EventRecorder;
  private imageNodeId: number = 1; // ID of the image node for touch interactions
  private screenRecorder?: any; // Reference to screen recorder for force capture
  private gestureEventListener?: any; // Native event listener
  private currentPanSpan?: Span; // Aggregated span for pan gesture
  private panMoveCount: number = 0;

  init(
    config: RecorderConfig,
    eventRecorder?: EventRecorder,
    screenRecorder?: any
  ): void {
    this.config = config;
    this.eventRecorder = eventRecorder;
    this.screenRecorder = screenRecorder;
    this._getScreenDimensions();
  }

  start(): void {
    logger.info('GestureRecorder', 'Native gesture recording started');
    this.isRecording = true;
    this.events = [];

    // Check if we're on web platform
    if (Platform.OS === 'web') {
      logger.warn(
        'GestureRecorder',
        'Native gesture recording not available on web platform'
      );
      return;
    }

    // Start native gesture recording
    SessionRecorderNative.startGestureRecording()
      .then(() => {
        logger.info(
          'GestureRecorder',
          'Native gesture recording started successfully'
        );
        this._setupGestureEventListener();
      })
      .catch((error) => {
        logger.error(
          'GestureRecorder',
          'Failed to start native gesture recording',
          error
        );
      });
  }

  stop(): void {
    this.isRecording = false;
    this._removeGestureEventListener();

    // Check if we're on web platform
    if (Platform.OS === 'web') {
      logger.warn(
        'GestureRecorder',
        'Native gesture recording not available on web platform'
      );
      return;
    }

    // Stop native gesture recording
    SessionRecorderNative.stopGestureRecording()
      .then(() => {
        logger.info(
          'GestureRecorder',
          'Native gesture recording stopped successfully'
        );
      })
      .catch((error) => {
        logger.error(
          'GestureRecorder',
          'Failed to stop native gesture recording',
          error
        );
      });
  }

  private _getScreenDimensions(): void {
    try {
      this.screenDimensions = Dimensions.get('window');
    } catch (error) {
      // Failed to get screen dimensions - silently continue
      this.screenDimensions = { width: 375, height: 667 }; // Default fallback
    }
  }

  private _setupGestureEventListener(): void {
    if (!gestureEventEmitter) {
      logger.warn('GestureRecorder', 'Gesture event emitter not available');
      return;
    }

    this.gestureEventListener = gestureEventEmitter.addListener(
      'onGestureDetected',
      (nativeGesture: any) => {
        this._handleNativeGesture(nativeGesture as NativeGestureEvent);
      }
    );
  }

  private _removeGestureEventListener(): void {
    if (this.gestureEventListener) {
      this.gestureEventListener.remove();
      this.gestureEventListener = undefined;
    }
  }

  private _handleNativeGesture(nativeGesture: NativeGestureEvent): void {
    if (!this.isRecording) return;

    // Throttle gestures to avoid spam
    const now = Date.now();
    if (now - this.lastGestureTime < this.gestureThrottleMs) {
      return;
    }
    this.lastGestureTime = now;

    // Convert native gesture to our format
    const gesture: GestureEvent = {
      type: nativeGesture.type as any,
      timestamp: nativeGesture.timestamp,
      coordinates: { x: nativeGesture.x, y: nativeGesture.y },
      target: nativeGesture.target,
      targetInfo: nativeGesture.targetInfo, // Pass through targetInfo from native
      metadata: {
        ...nativeGesture.metadata,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this.events.push(gesture);
    this._sendEvent(gesture);
    this._recordOpenTelemetrySpan(gesture);

    // Handle specific gesture types
    switch (nativeGesture.type) {
      case 'tap':
        this._handleTapGesture(nativeGesture);
        break;
      case 'pan_start':
        this._handlePanStartGesture(nativeGesture);
        break;
      case 'pan_move':
        this._handlePanMoveGesture(nativeGesture);
        break;
      case 'pan_end':
        this._handlePanEndGesture(nativeGesture);
        break;
      case 'long_press':
        this._handleLongPressGesture(nativeGesture);
        break;
      case 'pinch':
        this._handlePinchGesture(nativeGesture);
        break;
      case 'swipe':
        this._handleSwipeGesture(nativeGesture);
        break;
    }
  }

  private _handleTapGesture(nativeGesture: NativeGestureEvent): void {
    this.recordTouchStart(
      nativeGesture.x,
      nativeGesture.y,
      nativeGesture.target
    );
    this.recordTouchEnd(nativeGesture.x, nativeGesture.y, nativeGesture.target);
  }

  private _handlePanStartGesture(nativeGesture: NativeGestureEvent): void {
    this.recordTouchStart(
      nativeGesture.x,
      nativeGesture.y,
      nativeGesture.target
    );
  }

  private _handlePanMoveGesture(nativeGesture: NativeGestureEvent): void {
    this.recordTouchMove(
      nativeGesture.x,
      nativeGesture.y,
      nativeGesture.target
    );
  }

  private _handlePanEndGesture(nativeGesture: NativeGestureEvent): void {
    this.recordTouchEnd(nativeGesture.x, nativeGesture.y, nativeGesture.target);
  }

  private _handleLongPressGesture(nativeGesture: NativeGestureEvent): void {
    this.recordTouchStart(
      nativeGesture.x,
      nativeGesture.y,
      nativeGesture.target
    );
    this.recordTouchEnd(nativeGesture.x, nativeGesture.y, nativeGesture.target);
  }

  private _handlePinchGesture(nativeGesture: NativeGestureEvent): void {
    this.recordPinch(
      nativeGesture.metadata?.scale || 1.0,
      nativeGesture.target,
      nativeGesture.metadata?.velocity || 0
    );
  }

  private _handleSwipeGesture(nativeGesture: NativeGestureEvent): void {
    this.recordSwipe(
      nativeGesture.metadata?.direction || 'unknown',
      nativeGesture.target,
      nativeGesture.metadata?.velocity || 0
    );
  }

  private _sendEvent(event: GestureEvent): void {
    // Send event to backend or store locally
    logger.debug('GestureRecorder', 'Gesture event recorded', {
      type: event.type,
      target: event.target,
    });
  }

  private _recordOpenTelemetrySpan(event: GestureEvent): void {
    try {
      logger.debug('GestureRecorder', 'Creating OTEL span for native gesture', {
        type: event.type,
        target: event.target,
        targetInfo: event.targetInfo,
        hasTargetInfo: !!event.targetInfo,
      });
      // Special handling to aggregate pan gestures into a single span
      if (event.type === 'pan_start') {
        // End any previously dangling pan span defensively
        if (this.currentPanSpan) {
          this.currentPanSpan.setStatus({ code: SpanStatusCode.OK });
          this.currentPanSpan.end();
        }
        this.panMoveCount = 0;
        const panSpan = trace
          .getTracer('@opentelemetry/instrumentation-user-interaction')
          .startSpan('NativeGesture.pan', {
            startTime: event.timestamp,
          });

        panSpan.setAttribute('gesture.type', 'pan');
        panSpan.setAttribute('gesture.timestamp', event.timestamp);
        panSpan.setAttribute('gesture.platform', 'react-native');
        panSpan.setAttribute('gesture.source', 'native-module');

        if (event.coordinates) {
          panSpan.setAttribute('gesture.start.x', event.coordinates.x);
          panSpan.setAttribute('gesture.start.y', event.coordinates.y);
        }
        if (event.target) {
          panSpan.setAttribute(
            'gesture.target',
            this._truncateText(event.target, 50)
          );
        }
        // Enrich with target info if provided
        const info = event.targetInfo;
        if (info) {
          if (info.label) {
            const truncatedLabel = this._truncateText(String(info.label), 50);
            panSpan.setAttribute('gesture.target.label', truncatedLabel);
          }
          if (info.role) {
            panSpan.setAttribute('gesture.target.role', String(info.role));
          }
          if (info.testId) {
            panSpan.setAttribute('gesture.target.test_id', String(info.testId));
          }
          if (info.text) {
            const truncatedText = this._truncateText(String(info.text), 50);
            panSpan.setAttribute('gesture.target.text', truncatedText);
          }
        }
        // Save the span for subsequent move/end events
        this.currentPanSpan = panSpan;
        return;
      }

      if (event.type === 'pan_move') {
        if (this.currentPanSpan) {
          this.panMoveCount += 1;
          this.currentPanSpan.setAttribute(
            'gesture.pan.move_count',
            this.panMoveCount
          );
          if (event.coordinates) {
            this.currentPanSpan.setAttribute(
              'gesture.last.x',
              event.coordinates.x
            );
            this.currentPanSpan.setAttribute(
              'gesture.last.y',
              event.coordinates.y
            );
          }
          // Don't end the span here; just update it
          return;
        }
        // If we received a move without a start, fall through to single-shot span below
      }

      if (event.type === 'pan_end') {
        if (this.currentPanSpan) {
          if (event.coordinates) {
            this.currentPanSpan.setAttribute(
              'gesture.end.x',
              event.coordinates.x
            );
            this.currentPanSpan.setAttribute(
              'gesture.end.y',
              event.coordinates.y
            );
          }
          this.currentPanSpan.setStatus({ code: SpanStatusCode.OK });
          this.currentPanSpan.end();
          this.currentPanSpan = undefined;
          this.panMoveCount = 0;
          return;
        }
        // If no current span, fall through and create a single-shot span for the end event
      }

      // Default behavior: create a short-lived span per non-pan event
      const span = trace
        .getTracer('@opentelemetry/instrumentation-user-interaction')
        .startSpan(`NativeGesture.${event.type}`, {
          startTime: event.timestamp,
          attributes: {
            'gesture.type': event.type,
            'gesture.timestamp': event.timestamp,
            'gesture.platform': 'react-native',
            'gesture.source': 'native-module',
          },
        });

      if (event.coordinates) {
        span.setAttribute('gesture.coordinates.x', event.coordinates.x);
        span.setAttribute('gesture.coordinates.y', event.coordinates.y);

        // Calculate relative position
        if (this.screenDimensions) {
          const relativeX = event.coordinates.x / this.screenDimensions.width;
          const relativeY = event.coordinates.y / this.screenDimensions.height;
          span.setAttribute('gesture.coordinates.relative_x', relativeX);
          span.setAttribute('gesture.coordinates.relative_y', relativeY);
        }
      }

      if (event.target) {
        span.setAttribute(
          'gesture.target',
          this._truncateText(event.target, 100)
        );
      }

      // Enrich with target info if provided
      const info = event.targetInfo;
      if (info) {
        if (info.label) {
          const truncatedLabel = this._truncateText(String(info.label), 100);
          span.setAttribute('gesture.target.label', truncatedLabel);
        }
        if (info.role) {
          span.setAttribute('gesture.target.role', String(info.role));
        }
        if (info.testId) {
          span.setAttribute('gesture.target.test_id', String(info.testId));
        }
        if (info.text) {
          const truncatedText = this._truncateText(String(info.text), 200);
          span.setAttribute('gesture.target.text', truncatedText);
        }
      }

      if (event.metadata) {
        Object.entries(event.metadata).forEach(([key, value]) => {
          span.setAttribute(`gesture.metadata.${key}`, String(value));
        });
      }

      span.setStatus({ code: SpanStatusCode.OK });
      span.end();
      logger.debug(
        'GestureRecorder',
        'OTEL span created and ended successfully'
      );
    } catch (error) {
      logger.error(
        'GestureRecorder',
        'Failed to record OpenTelemetry span for native gesture',
        error
      );
    }
  }

  // Public methods for manual event recording (same as before)
  recordTap(
    x: number,
    y: number,
    target?: string,
    pressure?: number,
    timestamp?: number
  ): void {
    const event: GestureEvent = {
      type: 'tap',
      timestamp: timestamp || Date.now(),
      coordinates: { x, y },
      target,
      metadata: {
        pressure: pressure || 1.0,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordSwipe(
    direction: string,
    target?: string,
    velocity?: number,
    distance?: number
  ): void {
    const event: GestureEvent = {
      type: 'swipe',
      timestamp: Date.now(),
      target,
      metadata: {
        direction,
        velocity: velocity || 0,
        distance: distance || 0,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordPinch(scale: number, target?: string, velocity?: number): void {
    const event: GestureEvent = {
      type: 'pinch',
      timestamp: Date.now(),
      target,
      metadata: {
        scale,
        velocity: velocity || 0,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordPan(
    deltaX: number,
    deltaY: number,
    target?: string,
    velocity?: number
  ): void {
    const event: GestureEvent = {
      type: 'pan',
      timestamp: Date.now(),
      target,
      metadata: {
        deltaX,
        deltaY,
        velocity: velocity || 0,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordLongPress(duration: number, target?: string, pressure?: number): void {
    const event: GestureEvent = {
      type: 'longPress',
      timestamp: Date.now(),
      target,
      metadata: {
        duration,
        pressure: pressure || 1.0,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordDoubleTap(x: number, y: number, target?: string): void {
    const event: GestureEvent = {
      type: 'doubleTap',
      timestamp: Date.now(),
      coordinates: { x, y },
      target,
      metadata: {
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordRotate(rotation: number, target?: string, velocity?: number): void {
    const event: GestureEvent = {
      type: 'rotate',
      timestamp: Date.now(),
      target,
      metadata: {
        rotation,
        velocity: velocity || 0,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordFling(direction: string, velocity: number, target?: string): void {
    const event: GestureEvent = {
      type: 'fling',
      timestamp: Date.now(),
      target,
      metadata: {
        direction,
        velocity,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordMultiTouch(touchCount: number, target?: string): void {
    const event: GestureEvent = {
      type: 'multiTouch',
      timestamp: Date.now(),
      target,
      metadata: {
        touchCount,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordScroll(
    direction: string,
    distance: number,
    velocity: number,
    target?: string
  ): void {
    const event: GestureEvent = {
      type: 'scroll',
      timestamp: Date.now(),
      target,
      metadata: {
        direction,
        distance,
        velocity,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  recordZoom(scale: number, target?: string, velocity?: number): void {
    const event: GestureEvent = {
      type: 'zoom',
      timestamp: Date.now(),
      target,
      metadata: {
        scale,
        velocity: velocity || 0,
        screenWidth: this.screenDimensions?.width,
        screenHeight: this.screenDimensions?.height,
      },
    };

    this._recordEvent(event);
  }

  // Touch event methods (same as before)
  recordTouchStart(
    x: number,
    y: number,
    target?: string,
    pressure?: number
  ): void {
    // Throttle touch events to prevent spam
    const now = Date.now();
    if (now - this.lastTouchTime < this.touchThrottleMs) {
      logger.debug(
        'GestureRecorder',
        `Touch start throttled (${now - this.lastTouchTime}ms < ${this.touchThrottleMs}ms)`
      );
      return;
    }
    this.lastTouchTime = now;

    logger.debug('GestureRecorder', 'Touch start recorded', {
      x,
      y,
      target,
      pressure,
    });
    this._createMouseInteractionEvent(x, y, MouseInteractions.TouchStart, now);
  }

  recordTouchMove(
    x: number,
    y: number,
    target?: string,
    pressure?: number
  ): void {
    // Throttle touch move events more aggressively
    const now = Date.now();
    if (now - this.lastTouchTime < this.touchThrottleMs * 2) {
      // 200ms throttle for move events
      logger.debug(
        'GestureRecorder',
        `Touch move throttled (${now - this.lastTouchTime}ms < ${this.touchThrottleMs * 2}ms)`
      );
      return;
    }
    this.lastTouchTime = now;

    logger.debug('GestureRecorder', 'Touch move recorded', {
      x,
      y,
      target,
      pressure,
    });
    this._createMouseMoveEvent(x, y, target);
  }

  recordTouchEnd(
    x: number,
    y: number,
    target?: string,
    pressure?: number
  ): void {
    const timestamp = Date.now();

    logger.debug('GestureRecorder', 'Touch end recorded', {
      x,
      y,
      target,
      pressure,
      timestamp,
    });

    this.recordTap(x, y, target, pressure, timestamp);
    this._createMouseInteractionEvent(
      x,
      y,
      MouseInteractions.TouchEnd,
      timestamp
    );

    // Only force screen capture on touch end (not on every touch event)
    this.screenRecorder?.forceCapture(timestamp);
  }

  recordTouchCancel(x: number, y: number, _target?: string): void {
    this._createMouseInteractionEvent(x, y, MouseInteractions.TouchCancel);
  }

  setImageNodeId(nodeId: number): void {
    this.imageNodeId = nodeId;
  }

  private _recordEvent(event: GestureEvent): void {
    if (!this.isRecording) return;

    // Throttle gestures to avoid spam
    const now = Date.now();
    if (now - this.lastGestureTime < this.gestureThrottleMs) {
      return;
    }
    this.lastGestureTime = now;

    this.events.push(event);
    this._sendEvent(event);
    this._recordOpenTelemetrySpan(event);
  }

  private _createMouseInteractionEvent(
    x: number,
    y: number,
    interactionType: MouseInteractions,
    timestamp?: number
  ): void {
    const incrementalSnapshotEvent: eventWithTime = {
      type: EventType.IncrementalSnapshot,
      data: {
        source: IncrementalSource.MouseInteraction,
        type: interactionType,
        id: this.imageNodeId, // Reference to the image node
        x: x, // Preserve decimal precision like web rrweb
        y: y, // Preserve decimal precision like web rrweb
        pointerType: 2, // 2 = Touch for React Native (0=Mouse, 1=Pen, 2=Touch)
      },
      timestamp: timestamp || Date.now(),
    };

    this.recordEvent(incrementalSnapshotEvent);
  }

  private _createMouseMoveEvent(x: number, y: number, _target?: string): void {
    const incrementalSnapshotEvent: eventWithTime = {
      type: EventType.IncrementalSnapshot,
      data: {
        source: IncrementalSource.TouchMove, // Use MouseMove instead of MouseInteraction
        positions: [
          {
            x: x, // Preserve decimal precision like web rrweb
            y: y, // Preserve decimal precision like web rrweb
            id: this.imageNodeId, // Reference to the image node
            timeOffset: 0, // No time offset for single position
          },
        ],
      },
      timestamp: Date.now(),
    };

    this.recordEvent(incrementalSnapshotEvent);
  }

  recordEvent(event: any): void {
    if (this.eventRecorder) {
      this.eventRecorder.recordEvent(event);
    }
  }

  // Get recorded events
  getEvents(): GestureEvent[] {
    return [...this.events];
  }

  // Clear events
  clearEvents(): void {
    this.events = [];
  }

  // Get event statistics
  getEventStats(): Record<string, number> {
    const stats: Record<string, number> = {};
    this.events.forEach((event) => {
      stats[event.type] = (stats[event.type] || 0) + 1;
    });
    return stats;
  }

  // Set gesture throttle
  setGestureThrottle(throttleMs: number): void {
    this.gestureThrottleMs = throttleMs;
  }

  // Get recording status
  isRecordingEnabled(): boolean {
    return this.isRecording;
  }

  /**
   * Truncate text to prevent large span attributes
   * @param text - Text to truncate
   * @param maxLength - Maximum length (default: 100)
   * @returns Truncated text with ellipsis if needed
   */
  private _truncateText(text: string, maxLength: number = 100): string {
    if (!text || text.length <= maxLength) {
      return text;
    }
    return text.substring(0, maxLength - 3) + '...';
  }
}