import { useMobileCallOptimization } from '@/hooks/use-mobile-call-optimization'

function CallComponent() {
  const { initialize, enableBatterySavingMode, optimizationStatus } = useMobileCallOptimization({
    autoBatteryOptimization: true,
    autoEnablePiP: true,
    enableNativeCallUI: true,
    enableVoIPPush: true,
  })

  useEffect(() => {
    initialize()
  }, [])

  return (
    <div>
      {optimizationStatus.batteryOptimized && <BatteryWarning />}
      {optimizationStatus.pipEnabled && <PiPIndicator />}
      <MobileCallScreen />
    </div>
  )
}

import { callKitManager } from '@/platforms/capacitor/src/native/call-kit'

await callKitManager.initialize('nChat')

// Report incoming call (shows system UI)
const uuid = await callKitManager.reportIncomingCall({
  uuid: 'call-123',
  handle: '[email protected]',
  handleType: 'email',
  hasVideo: true,
  callerDisplayName: 'John Doe',
  callerImageUrl: 'https://example.com/avatar.jpg',
})

// Start outgoing call
const uuid = await callKitManager.startOutgoingCall({
  uuid: 'call-456',
  handle: '[email protected]',
  hasVideo: false,
})

// Report connected
await callKitManager.reportCallConnected(uuid)

// Mute/unmute
await callKitManager.setMuted(true, uuid)

// Hold/unhold
await callKitManager.setOnHold(true, uuid)

// End call
await callKitManager.endCall('completed', uuid)

// Listen for events
window.addEventListener('callkit:callAnswered', (event) => {
  const { uuid } = event.detail
  // Accept the call in your app
  acceptCall(uuid)
})

window.addEventListener('callkit:callEnded', (event) => {
  const { uuid } = event.detail
  // End the call in your app
  endCall(uuid)
})

import { CallKit } from '@/platforms/capacitor/src/native/call-kit'

const { granted } = await CallKit.requestPermissions()
if (!granted) {
  // Handle permission denied
}

import { useMobileCallOptimization } from '@/hooks/use-mobile-call-optimization'

function CallComponent() {
  const {
    enableBatterySavingMode,
    disableBatterySavingMode,
    isBatterySavingActive,
  } = useMobileCallOptimization()

  return (
    <div>
      <button onClick={enableBatterySavingMode}>
        Enable Battery Saving
      </button>
      {isBatterySavingActive && <span>Battery saving active</span>}
    </div>
  )
}

import { useBatteryStatus } from '@/hooks/use-battery-status'

function BatteryIndicator() {
  const {
    batteryLevel,
    isCharging,
    isLowBattery,
    isCriticalBattery,
    suggestedVideoQuality,
  } = useBatteryStatus()

  return (
    <div>
      <span>Battery: {batteryLevel}%</span>
      {isCharging && <span>⚡ Charging</span>}
      {isLowBattery && <span>⚠️ Low Battery</span>}
      {isCriticalBattery && <span>🔴 Critical Battery</span>}
      <span>Suggested Quality: {suggestedVideoQuality}</span>
    </div>
  )
}

import {
  getRecommendedFrameRate,
  getRecommendedResolution,
  shouldDisableVideo,
  getBatteryWarningMessage,
} from '@/hooks/use-battery-status'

// Get recommended settings
const frameRate = getRecommendedFrameRate(batteryLevel, isCharging)
const resolution = getRecommendedResolution(batteryLevel, isCharging)

// Check if video should be disabled
if (shouldDisableVideo(batteryLevel, isCharging)) {
  // Disable video
  setLocalVideoEnabled(false)
}

// Get warning message
const message = getBatteryWarningMessage(batteryLevel)
toast({ title: message })

import { useMobilePiP } from '@/hooks/use-mobile-pip'

function CallControls() {
  const {
    isPiPActive,
    isPiPSupported,
    enablePiP,
    disablePiP,
    togglePiP,
    error,
  } = useMobilePiP()

  if (!isPiPSupported) {
    return <span>PiP not supported on this device</span>
  }

  return (
    <div>
      <button onClick={togglePiP}>
        {isPiPActive ? 'Exit PiP' : 'Enter PiP'}
      </button>
      {error && <span>Error: {error}</span>}
    </div>
  )
}

import { MobilePiPOverlay } from '@/components/calls/mobile/MobilePiPOverlay'

function App() {
  const [isPiPActive, setIsPiPActive] = useState(false)

  return (
    <>
      <MobilePiPOverlay
        isActive={isPiPActive}
        onExpand={() => setIsPiPActive(false)}
        onEndCall={() => endCall()}
      />
    </>
  )
}

import { useMobileCallOptimization } from '@/hooks/use-mobile-call-optimization'
import { MobileCallScreen } from '@/components/calls/mobile/MobileCallScreen'
import { MobilePiPOverlay } from '@/components/calls/mobile/MobilePiPOverlay'
import { useCallStore } from '@/stores/call-store'

function MobileCallInterface() {
  const activeCall = useCallStore((state) => state.activeCall)
  const [showCallScreen, setShowCallScreen] = useState(true)

  // Initialize mobile call optimizations
  const {
    initialize,
    cleanup,
    optimizeCallQuality,
    enableBatterySavingMode,
    optimizationStatus,
  } = useMobileCallOptimization({
    autoBatteryOptimization: true,
    autoEnablePiP: true,
    lockOrientation: true,
    enableNativeCallUI: true,
    enableVoIPPush: true,
  })

  // Initialize on mount
  useEffect(() => {
    initialize()
    return () => {
      cleanup()
    }
  }, [initialize, cleanup])

  // Optimize quality when call starts
  useEffect(() => {
    if (activeCall) {
      optimizeCallQuality()
    }
  }, [activeCall, optimizeCallQuality])

  if (!activeCall) {
    return null
  }

  return (
    <>
      {/* Full-screen call interface */}
      <MobileCallScreen
        isVisible={showCallScreen}
        onMinimize={() => setShowCallScreen(false)}
        onOpenMore={() => {
          // Show call settings
        }}
      />

      {/* Floating PiP overlay */}
      <MobilePiPOverlay
        isActive={!showCallScreen}
        onExpand={() => setShowCallScreen(true)}
        onEndCall={() => {
          // End call
        }}
      />

      {/* Battery warning */}
      {optimizationStatus.batteryOptimized && (
        <div className="battery-warning">
          Battery optimization active
          <button onClick={enableBatterySavingMode}>
            Enable Battery Saving
          </button>
        </div>
      )}
    </>
  )
}

import { voipPushManager } from '@/lib/voip-push'

// Initialize VoIP push
await voipPushManager.initialize()

// Get push token (send this to your server)
const token = voipPushManager.getToken()

// Server-side: Send VoIP push when call initiated
import { sendVoIPPush } from '@/lib/voip-push'

await sendVoIPPush(userToken, 'ios', {
  type: 'incoming_call',
  callId: 'call-123',
  callerId: 'user-456',
  callerName: 'John Doe',
  callerAvatarUrl: 'https://example.com/avatar.jpg',
  callType: 'video',
})

interface MobileCallOptimizationOptions {
  autoBatteryOptimization?: boolean // Default: true
  autoEnablePiP?: boolean // Default: true
  lockOrientation?: boolean // Default: true
  enableNativeCallUI?: boolean // Default: true
  enableVoIPPush?: boolean // Default: true
}

interface UseMobileCallOptimizationReturn {
  initialize: () => Promise<void>
  cleanup: () => Promise<void>
  optimizeCallQuality: () => Promise<void>
  enableBatterySavingMode: () => Promise<void>
  disableBatterySavingMode: () => Promise<void>
  isBatterySavingActive: boolean
  optimizationStatus: {
    batteryOptimized: boolean
    pipEnabled: boolean
    callKitEnabled: boolean
    voipPushEnabled: boolean
  }
}

interface UseBatteryStatusReturn {
  batteryLevel: number // 0-100
  isCharging: boolean
  chargingTime: number | null // seconds
  dischargingTime: number | null // seconds
  isLowBattery: boolean // <20%
  isCriticalBattery: boolean // <10%
  isSupported: boolean
  suggestedVideoQuality: 'high' | 'medium' | 'low' | 'audio-only'
}

interface UseMobilePiPReturn {
  isPiPActive: boolean
  isPiPSupported: boolean
  enablePiP: () => Promise<void>
  disablePiP: () => Promise<void>
  togglePiP: () => Promise<void>
  error: string | null
}

interface UseMobileOrientationReturn {
  orientation: 'portrait' | 'landscape'
  isPortrait: boolean
  isLandscape: boolean
  lockPortrait: () => Promise<void>
  lockLandscape: () => Promise<void>
  unlockOrientation: () => Promise<void>
  isOrientationLockSupported: boolean
}

// Debug CallKit
const { supported } = await CallKit.isSupported()
console.log('CallKit supported:', supported)

const { granted } = await CallKit.requestPermissions()
if (!granted) {
  toast({
    title: 'Permissions Required',
    description: 'Call permissions are required for native call UI.',
  })
}

const { isSupported } = useBatteryStatus()
if (!isSupported) {
  console.warn('Battery API not supported on this device')
}

const { isPiPSupported, error } = useMobilePiP()
if (!isPiPSupported) {
  console.log('PiP not supported')
}
if (error) {
  console.error('PiP error:', error)
}

// Debug push token
const token = voipPushManager.getToken()
console.log('Push token:', token)