import SessionRecorderNative, {
  type MaskingOptions,
} from '../native/SessionRecorderNative';
import { logger } from '../utils';

export interface ScreenRecordingConfig {
  /** Whether screen masking is enabled */
  enabled: boolean;
  /** Whether to mask text inputs (UITextField, UITextView, React Native text components) */
  maskTextInputs?: boolean;
  /** Whether to mask images (UIImageView, React Native Image components) */
  maskImages?: boolean;
  /** Whether to mask buttons (UIButton) */
  maskButtons?: boolean;
  /** Whether to mask labels (UILabel) */
  maskLabels?: boolean;
  /** Whether to mask web views (WKWebView) */
  maskWebViews?: boolean;
  /** Whether to mask sandboxed views (system views that don't belong to current process) */
  maskSandboxedViews?: boolean;
}

export class ScreenRecordingService {
  private config: ScreenRecordingConfig;
  private isAvailable: boolean = false;

  constructor(
    config: ScreenRecordingConfig = {
      enabled: true,
      maskTextInputs: true,
      maskImages: false,
      maskButtons: false,
      maskLabels: false,
      maskWebViews: false,
      maskSandboxedViews: false,
    }
  ) {
    this.config = config;
    this.checkAvailability();
  }

  /**
   * Check if the native masking module is available
   */
  private checkAvailability(): void {
    try {
      // Try to access the native module to check if it's available
      if (
        SessionRecorderNative &&
        typeof SessionRecorderNative.captureAndMask === 'function'
      ) {
        this.isAvailable = true;
        logger.info(
          'ScreenRecordingService',
          'Screen masking native module is available'
        );
      } else {
        this.isAvailable = false;
        logger.warn(
          'ScreenRecordingService',
          'Screen masking native module is not available - auto-linking may still be in progress'
        );
      }
    } catch (error) {
      this.isAvailable = false;
      logger.error(
        'ScreenRecordingService',
        'Error checking screen masking availability:',
        error
      );
    }
  }

  /**
   * Capture screen with masking applied
   */
  async captureMaskedScreen(options: MaskingOptions): Promise<string | null> {
    if (!this.isAvailable || !this.config.enabled) {
      logger.warn(
        'ScreenRecordingService',
        'Screen masking is not available or disabled'
      );
      return null;
    }

    try {
      const maskingOptions: MaskingOptions = {
        ...this.config,
        ...options,
      };
      const maskedImageBase64 =
        await SessionRecorderNative.captureAndMaskWithOptions(maskingOptions);
      return maskedImageBase64;
    } catch (error) {
      logger.error(
        'ScreenRecordingService',
        'Failed to capture masked screen:',
        error
      );
      return null;
    }
  }

  /**
   * Capture screen with basic masking (no custom options)
   */
  async captureMaskedScreenBasic(): Promise<string | null> {
    if (!this.isAvailable || !this.config.enabled) {
      logger.warn(
        'ScreenRecordingService',
        'Screen masking is not available or disabled'
      );
      return null;
    }

    try {
      const maskedImageBase64 = await SessionRecorderNative.captureAndMask();
      return maskedImageBase64;
    } catch (error) {
      logger.error(
        'ScreenRecordingService',
        'Failed to capture masked screen (basic):',
        error
      );
      return null;
    }
  }

  /**
   * Update the masking configuration
   */
  updateConfig(config: Partial<ScreenRecordingConfig>): void {
    this.config = { ...this.config, ...config };
    logger.info(
      'ScreenRecordingService',
      'Screen masking configuration updated'
    );
  }

  /**
   * Check if screen masking is available
   */
  isScreenRecordingAvailable(): boolean {
    return this.isAvailable && this.config.enabled;
  }

  /**
   * Get the current configuration
   */
  getConfig(): ScreenRecordingConfig {
    return { ...this.config };
  }
}

// Create a singleton instance
export const screenRecordingService = new ScreenRecordingService();