import {
  type ScreenEvent,
  type RecorderConfig,
  type EventRecorder,
} from '../types';
import { type eventWithTime } from '@rrweb/types';
import { trace, SpanStatusCode } from '@opentelemetry/api';
import { Dimensions, Platform } from 'react-native';
import {
  createRecordingMetaEvent,
  createFullSnapshotEvent,
  createIncrementalSnapshotWithImageUpdate as createIncrementalSnapshotUtil,
  generateScreenHash,
  logger,
} from '../utils';
import {
  screenRecordingService,
  type ScreenRecordingConfig,
} from '../services/screenRecordingService';
const isWeb = Platform.OS === 'web';

export class ScreenRecorder implements EventRecorder {
  private config?: RecorderConfig;
  private isRecording = false;
  private generation = 0;
  private isBufferOnlyMode = false;
  private needsFullSnapshot = true;
  private events: ScreenEvent[] = [];
  private captureInterval?: any;
  private bufferSnapshotInterval?: any;
  private captureCount: number = 0;
  private maxCaptures: number = 100; // Limit captures to prevent memory issues
  private captureQuality: number = 0.2;
  private captureScale: number = 0.33;
  private captureFormat: 'png' | 'jpg' = 'jpg';
  private screenDimensions: { width: number; height: number } | null = null;
  private eventRecorder?: EventRecorder;
  private nodeIdCounter: number = 1;
  private lastScreenCapture: string | null = null;
  private lastScreenHash: string | null = null;
  private enableChangeDetection: boolean = true;
  private hashSampleSize: number = 100;
  private currentImageNodeId: number | null = null;
  private recordingConfig?: ScreenRecordingConfig;
  private viewShotRef: any = null;

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

    // Initialize masking configuration
    this.recordingConfig = {
      enabled: true,
      ...this.config.masking,
    };

    // Update the masking service configuration
    screenRecordingService.updateConfig(this.recordingConfig);
  }

  start(): void {
    this.isRecording = true;
    this.generation++;
    this.needsFullSnapshot = true;
    this.events = [];
    this.captureCount = 0;
    this.lastScreenCapture = null;
    this.lastScreenHash = null;
    this.currentImageNodeId = null; // Reset image node ID for new session
    logger.info('ScreenRecorder', 'Screen recording started');

    this._startPeriodicCapture();
    this._startBufferSnapshotInterval();
    // Capture initial screen immediately
    this._captureScreen();
  }

  stop(): void {
    this.isRecording = false;
    this.generation++;
    this._stopPeriodicCapture();
    this._stopBufferSnapshotInterval();
    // Screen recording stopped
  }

  pause(): void {
    this.isRecording = false;
    this._stopPeriodicCapture();
    this._stopBufferSnapshotInterval();
  }

  resume(): void {
    this.isRecording = true;
    this._startPeriodicCapture();
    this._startBufferSnapshotInterval();
  }

  /**
   * Enables behavior specific to crash-buffer-only mode.
   * In this mode we periodically force a full snapshot anchor for replayability.
   */
  setBufferOnlyMode(enabled: boolean): void {
    this.isBufferOnlyMode = enabled;
    if (!enabled) {
      this.needsFullSnapshot = false;
      this._stopBufferSnapshotInterval();
      return;
    }

    this.needsFullSnapshot = true;
    if (this.isRecording) {
      this._startBufferSnapshotInterval();
    }
  }

  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 _startPeriodicCapture(): void {
    if (this.captureInterval) {
      clearInterval(this.captureInterval);
    }

    // Capture screen every 5 seconds (reduced frequency)
    this.captureInterval = setInterval(() => {
      this._captureScreen();
    }, 5000);
  }

  private _stopPeriodicCapture(): void {
    if (this.captureInterval) {
      clearInterval(this.captureInterval);
      this.captureInterval = undefined;
    }
  }

  private _startBufferSnapshotInterval(): void {
    this._stopBufferSnapshotInterval();
    if (!this.isBufferOnlyMode) {
      return;
    }

    const configuredInterval =
      this.config?.buffering?.snapshotIntervalMs || 20000;
    const intervalMs = Math.max(5000, configuredInterval);
    this.bufferSnapshotInterval = setInterval(() => {
      // Force a fresh full snapshot anchor in buffer-only mode.
      this.needsFullSnapshot = true;
      void this._captureScreen();
    }, intervalMs);
  }

  private _stopBufferSnapshotInterval(): void {
    if (this.bufferSnapshotInterval) {
      clearInterval(this.bufferSnapshotInterval);
      this.bufferSnapshotInterval = undefined;
    }
  }

  private async _captureScreen(timestamp?: number): Promise<void> {
    if (!this.isRecording || this.captureCount >= this.maxCaptures) return;

    // Capture before any await so we can detect a stop/restart landing
    // on top of this in-flight capture. A post-await generation mismatch
    // means the recorder was restarted — publishing would mix node IDs.
    const gen = this.generation;

    try {
      const base64Image = await this._captureScreenBase64();
      if (gen !== this.generation) return;

      if (base64Image) {
        // Check if screen has changed by comparing with previous capture
        const hasChanged = this.enableChangeDetection
          ? this._hasScreenChanged(base64Image)
          : true;

        if (hasChanged) {
          // Keep replay segments anchored: buffer-only mode can force a full snapshot.
          const shouldEmitFullSnapshot =
            this.needsFullSnapshot ||
            this.currentImageNodeId === null ||
            !this.lastScreenCapture;

          if (!shouldEmitFullSnapshot) {
            const success = this.updateScreenWithIncrementalSnapshot(
              base64Image,
              timestamp
            );
            if (!success) {
              // Fallback to full snapshot if incremental update fails
              this._createAndEmitFullSnapshotEvent(base64Image, timestamp);
              this.needsFullSnapshot = false;
            }
          } else {
            // First capture, forced anchor, or no existing image node.
            this._createAndEmitFullSnapshotEvent(base64Image, timestamp);
            this.needsFullSnapshot = false;
          }

          this.lastScreenCapture = base64Image;
          this.lastScreenHash = this._generateScreenHash(base64Image);
          this.captureCount++;
        }
      }
    } catch (error) {
      this._recordScreenCaptureError(error as Error);
    }
  }

  private async _captureScreenBase64(): Promise<string | null> {
    try {
      // Check if we're on web platform
      if (isWeb) {
        logger.warn(
          'ScreenRecorder',
          'Screen capture not available on web platform'
        );
        return null;
      }

      // Try native masking first if available
      if (screenRecordingService.isScreenRecordingAvailable()) {
        logger.info(
          'ScreenRecorder',
          'Using native masking for screen capture'
        );
        const recordingImage = await screenRecordingService.captureMaskedScreen(
          {
            quality: this.captureQuality,
            scale: this.captureScale,
          }
        );

        if (recordingImage) {
          return recordingImage;
        }

        logger.warn(
          'ScreenRecorder',
          'Native masking failed, falling back to view-shot'
        );
      }

      // // Fallback to react-native-view-shot
      if (!this.viewShotRef) {
        logger.warn(
          'ScreenRecorder',
          'ViewShot ref not available for screen capture'
        );
        return null;
      }

      return null;

      // // Check if captureRef is available
      // if (!captureRef) {
      //   logger.warn('ScreenRecorder', 'react-native-view-shot not available');
      //   return null;
      // }

      // // Capture the screen using react-native-view-shot
      // const result = await captureRef(this.viewShotRef, {
      //   format: this.captureFormat,
      //   quality: this.captureQuality,
      //   result: 'base64',
      // });

      // return result;
    } catch (error) {
      logger.error(
        'ScreenRecorder',
        'Failed to capture screen. Make sure react-native-view-shot is properly installed and linked:',
        error
      );
      return null;
    }
  }

  private _createAndEmitFullSnapshotEvent(
    base64Image: string,
    timestamp?: number
  ): void {
    if (!this.screenDimensions) return;

    // Keep replay anchors valid: each full snapshot is explicitly preceded by meta.
    this.recordEvent(createRecordingMetaEvent());

    // Use the new createFullSnapshot method
    const fullSnapshotEvent = this.createFullSnapshot(base64Image, timestamp);
    this.recordEvent(fullSnapshotEvent);
  }

  /**
   * Create a full snapshot event with the given base64 image
   * @param base64Image - Base64 encoded image data
   * @param timestamp - Optional timestamp to use for the event
   * @returns Full snapshot event
   */
  createFullSnapshot(base64Image: string, timestamp?: number): eventWithTime {
    if (!this.screenDimensions) {
      throw new Error('Screen dimensions not available');
    }

    const { width, height } = this.screenDimensions;
    this.nodeIdCounter = 1;

    // Use utility function to create full snapshot event
    const fullSnapshotEvent = createFullSnapshotEvent(
      base64Image,
      width,
      height,
      this.captureFormat,
      { current: this.nodeIdCounter },
      timestamp
    );

    // Store the image node ID for future incremental updates
    // The image node ID is the first node created (after the document)
    this.currentImageNodeId = 0; // First element node is the image

    return fullSnapshotEvent;
  }

  /**
   * Create an incremental snapshot event with mutation data to update image src
   * @param base64Image - New base64 encoded image data
   * @param captureFormat - Image format (png, jpg, etc.)
   * @param timestamp - Optional timestamp to use for the event
   * @returns Incremental snapshot event with mutation data
   */
  createIncrementalSnapshotWithImageUpdate(
    base64Image: string,
    captureFormat?: string,
    timestamp?: number
  ): eventWithTime {
    return createIncrementalSnapshotUtil(
      base64Image,
      captureFormat || this.captureFormat,
      timestamp
    );
  }

  /**
   * Update the screen with a new image using incremental snapshot
   * @param base64Image - New base64 encoded image data
   * @param timestamp - Optional timestamp to use for the event
   * @returns true if update was successful, false otherwise
   */
  updateScreenWithIncrementalSnapshot(
    base64Image: string,
    timestamp?: number
  ): boolean {
    if (this.currentImageNodeId === null) {
      logger.warn(
        'ScreenRecorder',
        'No image node ID available for incremental update'
      );
      return false;
    }

    const incrementalEvent = this.createIncrementalSnapshotWithImageUpdate(
      base64Image,
      'jpg',
      timestamp
    );
    this.recordEvent(incrementalEvent);
    return true;
  }

  /**
   * Force a full snapshot (useful when screen dimensions change or for debugging)
   * @param base64Image - Base64 encoded image data
   */
  forceFullSnapshot(base64Image: string): void {
    this._createAndEmitFullSnapshotEvent(base64Image);
    this.lastScreenCapture = base64Image;
    this.lastScreenHash = this._generateScreenHash(base64Image);
    this.captureCount++;
  }

  /**
   * Check if the screen has changed by comparing with the previous capture
   * @param currentBase64 - Current screen capture as base64
   * @returns true if screen has changed, false otherwise
   */
  private _hasScreenChanged(currentBase64: string): boolean {
    // If this is the first capture, consider it changed
    if (!this.lastScreenCapture) {
      return true;
    }

    // Generate hash for current capture
    const currentHash = this._generateScreenHash(currentBase64);

    // Compare with previous hash
    return currentHash !== this.lastScreenHash;
  }

  /**
   * Generate a simple hash for screen comparison
   * This is a lightweight hash that focuses on the beginning and end of the base64 string
   * to detect changes without doing a full comparison
   * @param base64Image - Base64 encoded image
   * @returns Hash string for comparison
   */
  private _generateScreenHash(base64Image: string): string {
    return generateScreenHash(base64Image, this.hashSampleSize);
  }

  private _sendEvent(_event: ScreenEvent): void {
    // Screen event recorded
    // Send event to backend or store locally
  }

  private _recordOpenTelemetrySpan(event: ScreenEvent): void {
    try {
      const span = trace.getTracer('screen').startSpan(`Screen.${event.type}`, {
        attributes: {
          'screen.type': event.type,
          'screen.timestamp': event.timestamp,
          'screen.platform': 'react-native',
        },
      });

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

      span.setStatus({ code: SpanStatusCode.OK });
      span.end();
    } catch (error) {
      // Failed to record OpenTelemetry span for screen - silently continue
    }
  }

  private _recordScreenCaptureError(error: Error): void {
    try {
      const span = trace.getTracer('screen').startSpan('Screen.capture.error', {
        attributes: {
          'screen.error': true,
          'screen.error.type': error.name,
          'screen.error.message': error.message,
          'screen.timestamp': Date.now(),
        },
      });

      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
      span.recordException(error);
      span.end();
    } catch (spanError) {
      // Failed to record error span - silently continue
    }
  }

  // Configuration methods
  setCaptureInterval(intervalMs: number): void {
    if (this.captureInterval) {
      clearInterval(this.captureInterval);
    }

    if (this.isRecording) {
      this.captureInterval = setInterval(() => {
        this._captureScreen();
      }, intervalMs);
    }
  }

  setCaptureQuality(quality: number): void {
    this.captureQuality = Math.max(0.1, Math.min(1.0, quality));
  }

  setCaptureFormat(format: 'png' | 'jpg'): void {
    this.captureFormat = format;
  }

  setMaxCaptures(max: number): void {
    this.maxCaptures = Math.max(1, max);
  }

  /**
   * Enable or disable change detection
   * @param enabled - Whether to enable change detection
   */
  setChangeDetection(enabled: boolean): void {
    this.enableChangeDetection = enabled;
  }

  /**
   * Set the hash sample size for change detection
   * @param size - Number of characters to sample from each part of the image
   */
  setHashSampleSize(size: number): void {
    this.hashSampleSize = Math.max(10, Math.min(1000, size));
  }

  // Performance monitoring
  recordScreenPerformance(screenName: string, loadTime: number): void {
    const event: ScreenEvent = {
      screenName,
      type: 'screenCapture',
      timestamp: Date.now(),
      metadata: {
        screenName,
        loadTime,
        performance: 'monitoring',
        captureCount: this.captureCount,
      },
    };

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

  // Error tracking
  recordScreenError(error: Error, screenName?: string): void {
    const event: ScreenEvent = {
      screenName: screenName || 'unknown',
      type: 'screenCapture',
      timestamp: Date.now(),
      metadata: {
        error: true,
        errorType: error.name,
        errorMessage: error.message,
        screenName,
        captureCount: this.captureCount,
      },
    };

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

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

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

  // Get screen capture statistics
  getScreenStats(): Record<string, any> {
    const stats = {
      totalCaptures: this.captureCount,
      totalEvents: this.events.length,
      averageCaptureTime: 0,
      successRate: 0,
    };

    if (this.events.length > 0) {
      const captureTimes = this.events
        .map((event) => event.metadata?.captureTime || 0)
        .filter((time) => time > 0);

      if (captureTimes.length > 0) {
        stats.averageCaptureTime =
          captureTimes.reduce((a, b) => a + b, 0) / captureTimes.length;
      }

      const successfulCaptures = this.events.filter(
        (event) => event.dataUrl
      ).length;
      stats.successRate = (successfulCaptures / this.events.length) * 100;
    }

    return stats;
  }

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

  // Get current configuration
  getConfiguration(): Record<string, any> {
    return {
      captureInterval: this.captureInterval ? 2000 : 0, // Default 5 seconds
      captureQuality: this.captureQuality,
      captureFormat: this.captureFormat,
      maxCaptures: this.maxCaptures,
      screenDimensions: this.screenDimensions,
    };
  }

  // Shutdown
  shutdown(): void {
    this.stop();
    this.clearEvents();
    // Screen recorder shutdown
  }

  /**
   * Set the viewshot ref for screen capture
   * @param ref - React Native View ref for screen capture
   */
  setViewShotRef(ref: any): void {
    this.viewShotRef = ref;
  }

  /**
   * Force capture screen (useful after touch interactions)
   * This bypasses the change detection and always captures
   * @param timestamp - Optional timestamp to use for the capture event
   */
  forceCapture(timestamp?: number): void {
    if (!this.isRecording) {
      return;
    }

    this._captureScreen(timestamp);
  }

  /**
   * Record an rrweb event
   * @param event - The rrweb event to record
   */
  recordEvent(event: any): void {
    if (this.eventRecorder) {
      this.eventRecorder.recordEvent(event);
    }
  }
}