// Android Bridge - Interface between PWA and Android system
class AndroidBridge {
  constructor() {
    this.isAndroid = this.detectAndroid();
    this.apiLevel = this.getApiLevel();
    this.samsungFeatures = this.detectSamsung();
    this.permissions = new Set();
    
    this.init();
  }
  
  init() {
    if (!this.isAndroid) {
      console.log('Running in non-Android environment');
      this.mockAndroidInterface();
    }
    
    this.requestEssentialPermissions();
    this.setupBroadcastReceiver();
    this.startServices();
  }
  
  detectAndroid() {
    return /Android/i.test(navigator.userAgent) || 
           typeof window.Android !== 'undefined';
  }
  
  getApiLevel() {
    const match = navigator.userAgent.match(/Android\s(\d+)/);
    return match ? parseInt(match[1]) : 14;
  }
  
  detectSamsung() {
    return {
      isSamsung: /Samsung/i.test(navigator.userAgent) || 
                 /SM-S918/.test(navigator.userAgent),
      model: this.getSamsungModel(),
      features: ['edge_panel', 'bixby', 'secure_folder', 'dex']
    };
  }
  
  getSamsungModel() {
    const match = navigator.userAgent.match(/(SM-[A-Za-z0-9]+)/);
    return match ? match[1] : 'Unknown';
  }
  
  mockAndroidInterface() {
    // Create mock interface for testing on non-Android devices
    window.Android = {
      Settings: {
        get: (key) => localStorage.getItem(`android_${key}`) || '',
        put: (key, value) => localStorage.setItem(`android_${key}`, value)
      },
      PackageManager: {
        getInstalledApps: () => JSON.stringify([]),
        launchApp: (pkg) => {
          console.log(`Mock launch: ${pkg}`);
          window.open(`intent://${pkg}#Intent;package=${pkg};end`, '_blank');
        }
      },
      NotificationListener: {
        getActiveNotifications: () => '[]',
        cancelNotification: (id) => {}
      },
      Battery: {
        getStatus: () => JSON.stringify({ level: 84, charging: true })
      },
      Haptic: {
        perform: (type) => {
          if (navigator.vibrate) navigator.vibrate(20);
        }
      },
      GestureManager: {
        registerCallback: () => {}
      }
    };
  }
  
  async requestEssentialPermissions() {
    const permissions = [
      { name: 'notifications', required: true },
      { name: 'storage', required: false },
      { name: 'location', required: false }
    ];
    
    for (const perm of permissions) {
      try {
        if (perm.name === 'notifications' && 'Notification' in window) {
          const result = await Notification.requestPermission();
          if (result === 'granted') {
            this.permissions.add(perm.name);
          }
        }
      } catch (e) {
        console.warn(`Permission ${perm.name} failed:`, e);
      }
    }
  }
  
  setupBroadcastReceiver() {
    // Listen for Android system broadcasts
    if (window.Android?.BroadcastReceiver?.register) {
      window.Android.BroadcastReceiver.register('android.intent.action.BATTERY_CHANGED', (data) => {
        window.dispatchEvent(new CustomEvent('battery-update', { detail: data }));
      });
      
      window.Android.BroadcastReceiver.register('android.intent.action.SCREEN_ON', () => {
        window.dispatchEvent(new CustomEvent('screen-on'));
      });
    }
  }
  
  startServices() {
    // Start worker-based services
    if (window.workerBridge) {
      window.workerBridge.startSystemSync();
      window.workerBridge.fetchApps();
      window.workerBridge.fetchSettings();
      window.workerBridge.fetchNotifications();
    }
    
    // Register for periodic sync
    if ('periodicSync' in registration) {
      registration.periodicSync.register('content-sync', {
        minInterval: 24 * 60 * 60 * 1000 // 1 day
      }).catch(console.error);
    }
  }
  
  // Public API
  
  getSystemInfo() {
    return {
      isAndroid: this.isAndroid,
      apiLevel: this.apiLevel,
      samsung: this.samsungFeatures,
      userAgent: navigator.userAgent,
      screen: {
        width: screen.width,
        height: screen.height,
        density: window.devicePixelRatio
      },
      memory: navigator.deviceMemory || 'unknown',
      connection: this.getConnectionInfo()
    };
  }
  
  getConnectionInfo() {
    const conn = navigator.connection;
    return {
      type: conn?.effectiveType || 'unknown',
      saveData: conn?.saveData || false,
      rtt: conn?.rtt,
      downlink: conn?.downlink
    };
  }
  
  async share(data) {
    if (navigator.share) {
      return navigator.share(data);
    }
    
    // Fallback to Android share
    if (window.Android?.Intent?.share) {
      window.Android.Intent.share(JSON.stringify(data));
    }
  }
  
  setWallpaper(uri) {
    if (this.samsungFeatures.isSamsung && window.Android?.Wallpaper?.set) {
      window.Android.Wallpaper.set(uri);
    }
  }
  
  openSystemSettings(setting) {
    const settingUris = {
      'display': 'android.settings.DISPLAY_SETTINGS',
      'sound': 'android.settings.SOUND_SETTINGS',
      'wifi': 'android.settings.WIFI_SETTINGS',
      'bluetooth': 'android.settings.BLUETOOTH_SETTINGS',
      'notification': 'android.settings.NOTIFICATION_SETTINGS',
      'apps': 'android.settings.MANAGE_APPLICATIONS_SETTINGS',
      'battery': 'android.settings.BATTERY_SAVER_SETTINGS',
      'storage': 'android.settings.INTERNAL_STORAGE_SETTINGS'
    };
    
    if (window.Android?.Intent?.openSettings) {
      window.Android.Intent.openSettings(settingUris[setting] || settingUris.display);
    }
  }
}

// Initialize
window.androidBridge = new AndroidBridge();