import ExpoGeofencing from 'expo-geofencing';
import * as Location from 'expo-location';

// Request permissions
await Location.requestForegroundPermissionsAsync();
await Location.requestBackgroundPermissionsAsync();

// Add a geofence
await ExpoGeofencing.addGeofence({
  id: 'home',
  latitude: 37.7749,
  longitude: -122.4194,
  radius: 100,
  notifyOnEntry: true,
  notifyOnExit: true,
});

// Listen for events
const unsubscribe = ExpoGeofencing.addGeofenceListener((event) => {
  console.log(`${event.eventType} region: ${event.regionId}`);
});

// Start monitoring with health checks
await ExpoGeofencing.setHealthCheckInterval(5 * 60 * 1000); // 5 minutes

// Check if battery optimization is enabled
const status = await ExpoGeofencing.checkBatteryOptimization();
if (status.isBatteryOptimized) {
  // Show device-specific instructions
  console.log(status.deviceInstructions);
  
  // Request to disable optimization
  await ExpoGeofencing.requestBatteryOptimizationDisable();
}

// Listen for health alerts
ExpoGeofencing.addHealthAlertListener((alert) => {
  console.log(`Health Alert: ${alert.title}`);
  if (alert.title.includes('Permission Denied')) {
    // Handle permission issues
  }
});

// Force location check for testing
const location = await ExpoGeofencing.forceLocationCheck();

import { PolygonGeofenceManager } from 'expo-geofencing';

const polygonManager = new PolygonGeofenceManager();

// Add complex shaped geofence
polygonManager.addGeofence({
  id: 'shopping-center',
  type: 'polygon',
  vertices: [
    { latitude: 37.7749, longitude: -122.4194 },
    { latitude: 37.7759, longitude: -122.4184 },
    { latitude: 37.7739, longitude: -122.4174 }
  ],
  notifyOnEntry: true,
  notifyOnExit: true,
  timeRules: [{
    id: 'business-hours',
    startTime: '09:00',
    endTime: '17:00',
    daysOfWeek: [1, 2, 3, 4, 5], // Monday-Friday
    isActive: true
  }]
});

import { OfflineManager } from 'expo-geofencing';

const offlineManager = new OfflineManager();

// Add geofences for offline evaluation
offlineManager.addGeofence(geofenceRegion);

// Evaluate location even when offline
const events = offlineManager.evaluateLocation({
  latitude: 37.7749,
  longitude: -122.4194,
  accuracy: 10,
  timestamp: Date.now()
});

// Sync when network returns
await offlineManager.syncPendingEvents();

import { WebhookManager } from 'expo-geofencing';

const webhookManager = new WebhookManager();

// Add webhook for real-time notifications
webhookManager.addWebhook({
  name: 'Geofence Alerts',
  url: 'https://api.example.com/webhooks/geofence',
  method: 'POST',
  events: ['geofence.enter', 'geofence.exit'],
  authConfig: {
    type: 'bearer',
    credentials: { token: 'your-api-token' }
  },
  retryConfig: {
    maxRetries: 3,
    backoffStrategy: 'exponential'
  }
});

import { DataManager } from 'expo-geofencing';

const dataManager = new DataManager({
  encryptData: true,
  retentionDays: 30,
  anonymizeData: true
});

// Generate analytics
const analytics = await dataManager.generateAnalytics();
console.log('Total events:', analytics.summary.totalEvents);

// Export data for compliance
const csvData = await dataManager.exportData('csv', {
  start: Date.now() - 30 * 24 * 60 * 60 * 1000, // Last 30 days
  end: Date.now()
});

import { SecurityManager } from 'expo-geofencing';

const securityManager = new SecurityManager({
  encryptionEnabled: true,
  privacyZonesEnabled: true,
  dataAnonymization: true
});

// Add privacy zone around hospital
securityManager.addPrivacyZone({
  name: 'Hospital Privacy Zone',
  type: 'hospital',
  center: { latitude: 37.7749, longitude: -122.4194 },
  radius: 200,
  bufferZone: 50
});

// Process location with privacy protection
const result = securityManager.processLocation({
  latitude: 37.7749,
  longitude: -122.4194,
  accuracy: 10
});

// Geofence Management
addGeofence(region: GeofenceRegion): Promise<void>
removeGeofence(regionId: string): Promise<void>
removeAllGeofences(): Promise<void>

// Activity Recognition
startActivityRecognition(intervalMs: number): Promise<void>
stopActivityRecognition(): Promise<void>

// Location Updates
startLocationUpdates(options: LocationUpdateOptions): Promise<void>
stopLocationUpdates(): Promise<void>

// Event Listeners
addGeofenceListener(callback: (event: GeofenceEvent) => void): () => void
addActivityListener(callback: (result: ActivityRecognitionResult) => void): () => void
addHealthAlertListener(callback: (alert: HealthAlert) => void): () => void

// Health & Monitoring
setHealthCheckInterval(intervalMs: number): Promise<void>
forceLocationCheck(): Promise<LocationData>
getServiceStatus(): Promise<SystemStatus>

// Android-specific
checkBatteryOptimization(): Promise<BatteryOptimizationStatus>
requestBatteryOptimizationDisable(): Promise<boolean>
openLocationSettings(): Promise<void>

// iOS-specific
checkSystemStatus(): Promise<SystemStatus>
requestPermissions(): Promise<boolean>

interface GeofenceRegion {
  id: string;
  latitude: number;
  longitude: number;
  radius: number;
  notifyOnEntry: boolean;
  notifyOnExit: boolean;
}

interface ActivityRecognitionResult {
  activity: 'still' | 'walking' | 'running' | 'driving' | 'cycling' | 'unknown';
  confidence: number;
  timestamp: number;
}

interface GeofenceEvent {
  regionId: string;
  eventType: 'enter' | 'exit';
  timestamp: number;
  latitude: number;
  longitude: number;
}

interface HealthAlert {
  type: string;
  title: string;
  message: string;
  timestamp: number;
  severity: 'low' | 'medium' | 'high' | 'critical';
}