// src/lib/environment.ts
export const getBackendUrls = () => {
  const isProduction = process.env.NODE_ENV === 'production'

  return {
    graphql:
      process.env.NEXT_PUBLIC_GRAPHQL_URL ||
      (isProduction ? 'https://api.nchat.nself.org/v1/graphql' : 'http://api.localhost/v1/graphql'),

    auth:
      process.env.NEXT_PUBLIC_AUTH_URL ||
      (isProduction ? 'https://auth.nchat.nself.org/v1/auth' : 'http://auth.localhost/v1/auth'),

    storage:
      process.env.NEXT_PUBLIC_STORAGE_URL ||
      (isProduction
        ? 'https://storage.nchat.nself.org/v1/storage'
        : 'http://storage.localhost/v1/storage'),

    websocket:
      process.env.NEXT_PUBLIC_WS_URL ||
      (isProduction ? 'wss://api.nchat.nself.org/v1/graphql' : 'ws://api.localhost/v1/graphql'),
  }
}

// capacitor.config.ts
import { CapacitorConfig } from '@capacitor/cli'

const config: CapacitorConfig = {
  appId: 'io.nself.chat',
  appName: 'nchat',
  webDir: 'out',
  server: {
    androidScheme: 'https',
    iosScheme: 'https',
  },
  plugins: {
    PushNotifications: {
      presentationOptions: ['badge', 'sound', 'alert'],
    },
    SplashScreen: {
      launchShowDuration: 2000,
      backgroundColor: '#ffffff',
      androidSplashResourceName: 'splash',
      showSpinner: false,
    },
  },
  ios: {
    contentInset: 'automatic',
    preferredContentMode: 'mobile',
  },
  android: {
    minWebViewVersion: 80,
  },
}

export default config

// platforms/capacitor/src/native/push-notifications.ts
import { PushNotifications } from '@capacitor/push-notifications'

class PushNotificationService {
  async initialize(): Promise<void> {
    const permission = await PushNotifications.requestPermissions()
    if (permission.receive === 'granted') {
      await PushNotifications.register()
      this.setupListeners()
    }
  }

  private setupListeners(): void {
    PushNotifications.addListener('registration', (token) => {
      // Send token to backend
      this.sendTokenToServer(token.value)
    })

    PushNotifications.addListener('pushNotificationReceived', (notification) => {
      this.handleForegroundNotification(notification)
    })

    PushNotifications.addListener('pushNotificationActionPerformed', (action) => {
      this.handleNotificationTapped(action.notification)
    })
  }
}

// Same Capacitor code works for both platforms
// FCM token is automatically retrieved on Android

// platforms/electron/main/notifications.ts
import { Notification } from 'electron'

export function showNotification(title: string, body: string): void {
  new Notification({
    title,
    body,
    icon: getAppIcon(),
    silent: !settings.notificationSound,
  }).show()
}

// platforms/capacitor/src/native/biometrics.ts
import { BiometricAuth } from '@aparajita/capacitor-biometric-auth'

export async function authenticate(): Promise<boolean> {
  const result = await BiometricAuth.checkBiometry()

  if (!result.isAvailable) {
    return false
  }

  try {
    await BiometricAuth.authenticate({
      reason: 'Verify your identity',
      cancelTitle: 'Cancel',
      iosFallbackTitle: 'Use Passcode',
    })
    return true
  } catch {
    return false
  }
}

// Same code works via Capacitor plugin
// Plugin handles platform detection automatically

// Using Capacitor Secure Storage
import { SecureStorage } from '@aparajita/capacitor-secure-storage'

export async function storeSecurely(key: string, value: string): Promise<void> {
  await SecureStorage.set(key, value)
}

export async function retrieveSecurely(key: string): Promise<string | null> {
  return SecureStorage.get(key)
}

// Same Capacitor API works on Android
// Backed by Android Keystore system

import keytar from 'keytar'

export async function getAuthToken(userId: string): Promise<string | null> {
  return keytar.getPassword('nchat', userId)
}

// Configure in Info.plist
// UIBackgroundModes: fetch, remote-notification

import { App } from '@capacitor/app'

App.addListener('appStateChange', ({ isActive }) => {
  if (!isActive) {
    // App went to background - schedule sync
    schedulePendingMessages()
  }
})

// Configure via Capacitor Background Task plugin
import { BackgroundTask } from '@capawesome/capacitor-background-task'

BackgroundTask.beforeExit(async () => {
  // Sync pending messages
  await syncPendingMessages()
  BackgroundTask.finish({ taskId })
})

// src/shared/platform/index.ts
export interface PlatformService {
  // Storage
  getSecureItem(key: string): Promise<string | null>
  setSecureItem(key: string, value: string): Promise<void>
  removeSecureItem(key: string): Promise<void>

  // Notifications
  requestNotificationPermission(): Promise<boolean>
  showNotification(title: string, body: string, data?: any): Promise<void>

  // Biometrics
  isBiometricsAvailable(): Promise<boolean>
  authenticateWithBiometrics(): Promise<boolean>

  // Platform info
  getPlatform(): 'web' | 'ios' | 'android' | 'macos' | 'windows' | 'linux'
  getVersion(): string
}

// src/shared/platform/web.ts
export const webPlatform: PlatformService = {
  getPlatform: () => 'web',
  getSecureItem: async (key) => localStorage.getItem(key),
  setSecureItem: async (key, value) => localStorage.setItem(key, value),
  // ... web implementations
}

// src/shared/platform/capacitor.ts
export const capacitorPlatform: PlatformService = {
  getPlatform: () => Capacitor.getPlatform() as any,
  getSecureItem: async (key) => SecureStorage.get(key),
  setSecureItem: async (key, value) => SecureStorage.set(key, value),
  // ... native implementations
}

// src/shared/platform/factory.ts
import { PlatformService } from './index'

let platform: PlatformService

export async function getPlatform(): Promise<PlatformService> {
  if (platform) return platform

  if (typeof window !== 'undefined' && (window as any).Capacitor) {
    const { capacitorPlatform } = await import('./capacitor')
    platform = capacitorPlatform
  } else if (typeof window !== 'undefined' && (window as any).__TAURI__) {
    const { tauriPlatform } = await import('./tauri')
    platform = tauriPlatform
  } else if (typeof window !== 'undefined' && (window as any).electron) {
    const { electronPlatform } = await import('./electron')
    platform = electronPlatform
  } else {
    const { webPlatform } = await import('./web')
    platform = webPlatform
  }

  return platform
}