import SwiftUI
import CoreLocation
import CoreMotion
import AVFoundation
import BackgroundTasks

/**
 * QUIXZOOM Production Capture App v1.1
 *
 * Real World Validation requirements:
 * - Automatic upload to S3
 * - Real-time GPS (±3m accuracy)
 * - Sensor data (gyro, accelerometer, compass)
 * - Background sync
 * - AI-guided capture
 * - Offline mode with local queue
 * - Battery optimization
 */

@main
struct QuixZoomCaptureApp: App {
    @UIApplicationDelegateAdaptor(AppDelegate.self) var appDelegate
    
    var body: some Scene {
        WindowGroup {
            ContentView()
        }
    }
}

class AppDelegate: NSObject, UIApplicationDelegate {
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey : Any]? = nil) -> Bool {
        // Register background tasks
        BGTaskScheduler.shared.register(forTaskWithIdentifier: "com.quixzoom.sync", using: nil) { task in
            self.handleBackgroundSync(task: task as! BGAppRefreshTask)
        }
        
        // Request permissions
        LocationManager.shared.requestPermissions()
        
        return true
    }
    
    func applicationDidEnterBackground(_ application: UIApplication) {
        scheduleBackgroundSync()
    }
    
    func scheduleBackgroundSync() {
        let request = BGAppRefreshTaskRequest(identifier: "com.quixzoom.sync")
        request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60) // 15 minutes
        
        do {
            try BGTaskScheduler.shared.submit(request)
        } catch {
            print("Could not schedule background sync: \(error)")
        }
    }
    
    func handleBackgroundSync(task: BGAppRefreshTask) {
        scheduleBackgroundSync() // Schedule next
        
        let queue = UploadQueue.shared
        
        task.expirationHandler = {
            queue.cancelAllUploads()
        }
        
        queue.processPendingUploads { success in
            task.setTaskCompleted(success: success)
        }
    }
}

// MARK: - Location Manager

class LocationManager: NSObject, ObservableObject {
    static let shared = LocationManager()
    private let locationManager = CLLocationManager()
    
    @Published var location: CLLocation?
    @Published var authorizationStatus: CLAuthorizationStatus?
    
    override init() {
        super.init()
        locationManager.delegate = self
        locationManager.desiredAccuracy = kCLLocationAccuracyBest // ±3m
        locationManager.allowsBackgroundLocationUpdates = true
        locationManager.pausesLocationUpdatesAutomatically = false
    }
    
    func requestPermissions() {
        locationManager.requestAlwaysAuthorization()
    }
    
    func startUpdating() {
        locationManager.startUpdatingLocation()
    }
    
    func stopUpdating() {
        locationManager.stopUpdatingLocation()
    }
}

extension LocationManager: CLLocationManagerDelegate {
    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        location = locations.last
    }
    
    func locationManager(_ manager: CLLocationManager, didChangeAuthorization status: CLAuthorizationStatus) {
        authorizationStatus = status
    }
}

// MARK: - Sensor Manager

class SensorManager: ObservableObject {
    static let shared = SensorManager()
    private let motionManager = CMMotionManager()
    
    @Published var accelerometerData: CMAccelerometerData?
    @Published var gyroData: CMGyroData?
    @Published var magnetometerData: CMMagnetometerData?
    
    func startUpdates() {
        if motionManager.isAccelerometerAvailable {
            motionManager.accelerometerUpdateInterval = 0.1
            motionManager.startAccelerometerUpdates(to: .main) { [weak self] data, _ in
                self?.accelerometerData = data
            }
        }
        
        if motionManager.isGyroAvailable {
            motionManager.gyroUpdateInterval = 0.1
            motionManager.startGyroUpdates(to: .main) { [weak self] data, _ in
                self?.gyroData = data
            }
        }
        
        if motionManager.isMagnetometerAvailable {
            motionManager.magnetometerUpdateInterval = 0.1
            motionManager.startMagnetometerUpdates(to: .main) { [weak self] data, _ in
                self?.magnetometerData = data
            }
        }
    }
    
    func stopUpdates() {
        motionManager.stopAccelerometerUpdates()
        motionManager.stopGyroUpdates()
        motionManager.stopMagnetometerUpdates()
    }
}

// MARK: - Capture Session

class CaptureSession: ObservableObject {
    @Published var isCapturing = false
    @Published var lastCapture: CaptureRecord?
    @Published var captureCount = 0
    
    private let uploadQueue = UploadQueue.shared
    
    func capture(image: UIImage, location: CLLocation?, sensors: SensorData?) {
        isCapturing = true
        
        let record = CaptureRecord(
            id: UUID().uuidString,
            timestamp: Date(),
            image: image,
            location: location,
            sensors: sensors,
            quality: assessQuality(image: image)
        )
        
        lastCapture = record
        captureCount += 1
        
        // Add to upload queue
        uploadQueue.add(record)
        
        isCapturing = false
    }
    
    private func assessQuality(image: UIImage) -> CaptureQuality {
        // Assess blur, exposure, noise
        // Simplified: check resolution and basic metrics
        let resolution = image.size.width * image.size.height
        let isHighRes = resolution >= (1920 * 1080)
        
        return CaptureQuality(
            resolution: isHighRes ? "high" : "medium",
            blur: 0.1, // Would use CV for real assessment
            exposure: 0.9,
            overall: isHighRes ? 0.9 : 0.7
        )
    }
}

// MARK: - Upload Queue

class UploadQueue {
    static let shared = UploadQueue()
    
    private var pendingUploads: [CaptureRecord] = []
    private let queue = DispatchQueue(label: "com.quixzoom.upload")
    private var isProcessing = false
    
    func add(_ record: CaptureRecord) {
        queue.async {
            self.pendingUploads.append(record)
            self.processNext()
        }
    }
    
    private func processNext() {
        guard !isProcessing, !pendingUploads.isEmpty else { return }
        
        isProcessing = true
        let record = pendingUploads.removeFirst()
        
        upload(record) { [weak self] success in
            self?.queue.async {
                self?.isProcessing = false
                if !success {
                    // Re-queue for retry
                    self?.pendingUploads.append(record)
                }
                self?.processNext()
            }
        }
    }
    
    private func upload(_ record: CaptureRecord, completion: @escaping (Bool) -> Void) {
        // Upload to S3
        // Simplified: would use AWS SDK
        DispatchQueue.global().asyncAfter(deadline: .now() + 2) {
            completion(true)
        }
    }
    
    func processPendingUploads(completion: @escaping (Bool) -> Void) {
        queue.async {
            while !self.pendingUploads.isEmpty {
                self.processNext()
            }
            completion(true)
        }
    }
    
    func cancelAllUploads() {
        queue.async {
            self.isProcessing = false
        }
    }
    
    var pendingCount: Int {
        return pendingUploads.count
    }
}

// MARK: - Data Models

struct CaptureRecord {
    let id: String
    let timestamp: Date
    let image: UIImage
    let location: CLLocation?
    let sensors: SensorData?
    let quality: CaptureQuality
}

struct SensorData {
    let acceleration: CMAcceleration?
    let rotation: CMRotationRate?
    let magneticField: CMMagneticField?
}

struct CaptureQuality {
    let resolution: String
    let blur: Double
    let exposure: Double
    let overall: Double
}

// MARK: - AI Guidance

class AIGuidance: ObservableObject {
    @Published var currentInstruction: String?
    @Published var confidence: Double = 0.0
    
    func analyzeFrame(_ image: UIImage, location: CLLocation?) {
        // Mock AI guidance
        // In production: send to API for real-time analysis
        
        let instructions = [
            "Move closer to the object",
            "Rotate 30° to the right",
            "Tilt camera up slightly",
            "Step back for wider view",
            "Good capture! Move to next object"
        ]
        
        currentInstruction = instructions.randomElement()
        confidence = Double.random(in: 0.7...0.95)
    }
}

// MARK: - Content View

struct ContentView: View {
    @StateObject private var locationManager = LocationManager.shared
    @StateObject private var sensorManager = SensorManager.shared
    @StateObject private var captureSession = CaptureSession()
    @StateObject private var aiGuidance = AIGuidance()
    
    @State private var showCamera = false
    @State private var capturedImage: UIImage?
    
    var body: some View {
        NavigationView {
            VStack(spacing: 20) {
                // Status Header
                StatusHeader(
                    location: locationManager.location,
                    captureCount: captureSession.captureCount,
                    pendingUploads: UploadQueue.shared.pendingCount
                )
                
                // AI Guidance
                if let instruction = aiGuidance.currentInstruction {
                    AIGuidanceCard(instruction: instruction, confidence: aiGuidance.confidence)
                }
                
                // Capture Button
                CaptureButton(isCapturing: captureSession.isCapturing) {
                    showCamera = true
                }
                
                // Recent Captures
                if let lastCapture = captureSession.lastCapture {
                    LastCaptureCard(capture: lastCapture)
                }
                
                // Sensor Data
                SensorDataCard(
                    accelerometer: sensorManager.accelerometerData,
                    gyro: sensorManager.gyroData
                )
                
                Spacer()
            }
            .padding()
            .navigationTitle("QUIXZOOM Capture")
        }
        .sheet(isPresented: $showCamera) {
            CameraView { image in
                capturedImage = image
                
                let sensorData = SensorData(
                    acceleration: sensorManager.accelerometerData?.acceleration,
                    rotation: sensorManager.gyroData?.rotationRate,
                    magneticField: sensorManager.magnetometerData?.magneticField
                )
                
                captureSession.capture(
                    image: image,
                    location: locationManager.location,
                    sensors: sensorData
                )
                
                aiGuidance.analyzeFrame(image, location: locationManager.location)
            }
        }
        .onAppear {
            locationManager.startUpdating()
            sensorManager.startUpdates()
        }
        .onDisappear {
            locationManager.stopUpdating()
            sensorManager.stopUpdates()
        }
    }
}

// MARK: - UI Components

struct StatusHeader: View {
    let location: CLLocation?
    let captureCount: Int
    let pendingUploads: Int
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            HStack {
                Image(systemName: "location.fill")
                    .foregroundColor(location != nil ? .green : .red)
                Text(location != nil ? "GPS Ready" : "GPS unavailable")
                    .font(.caption)
                
                Spacer()
                
                Text("\(captureCount) captures")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
            
            if let loc = location {
                Text("Accuracy: \(String(format: "%.1f", loc.horizontalAccuracy))m")
                    .font(.caption2)
                    .foregroundColor(loc.horizontalAccuracy < 5 ? .green : .orange)
            }
            
            if pendingUploads > 0 {
                Text("\(pendingUploads) pending uploads")
                    .font(.caption)
                    .foregroundColor(.orange)
            }
        }
        .padding()
        .background(Color(.systemGray6))
        .cornerRadius(12)
    }
}

struct AIGuidanceCard: View {
    let instruction: String
    let confidence: Double
    
    var body: some View {
        HStack {
            Image(systemName: "wand.and.stars")
                .foregroundColor(.blue)
            
            VStack(alignment: .leading) {
                Text("AI Guidance")
                    .font(.caption)
                    .foregroundColor(.secondary)
                Text(instruction)
                    .font(.subheadline)
                    .fontWeight(.medium)
            }
            
            Spacer()
            
            Text("\(Int(confidence * 100))%")
                .font(.caption)
                .foregroundColor(confidence > 0.8 ? .green : .orange)
        }
        .padding()
        .background(Color.blue.opacity(0.1))
        .cornerRadius(12)
    }
}

struct CaptureButton: View {
    let isCapturing: Bool
    let action: () -> Void
    
    var body: some View {
        Button(action: action) {
            ZStack {
                Circle()
                    .fill(Color.red)
                    .frame(width: 80, height: 80)
                
                Circle()
                    .stroke(Color.white, lineWidth: 4)
                    .frame(width: 70, height: 70)
                
                if isCapturing {
                    ProgressView()
                        .progressViewStyle(CircularProgressViewStyle(tint: .white))
                }
            }
        }
        .disabled(isCapturing)
    }
}

struct LastCaptureCard: View {
    let capture: CaptureRecord
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text("Last Capture")
                .font(.caption)
                .foregroundColor(.secondary)
            
            HStack {
                Image(uiImage: capture.image)
                    .resizable()
                    .scaledToFit()
                    .frame(height: 60)
                    .cornerRadius(8)
                
                VStack(alignment: .leading) {
                    Text("Quality: \(String(format: "%.0f", capture.quality.overall * 100))%")
                        .font(.caption)
                    
                    if let location = capture.location {
                        Text("Accuracy: \(String(format: "%.1f", location.horizontalAccuracy))m")
                            .font(.caption2)
                            .foregroundColor(.secondary)
                    }
                }
            }
        }
        .padding()
        .background(Color(.systemGray6))
        .cornerRadius(12)
    }
}

struct SensorDataCard: View {
    let accelerometer: CMAccelerometerData?
    let gyro: CMGyroData?
    
    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            Text("Sensors")
                .font(.caption)
                .foregroundColor(.secondary)
            
            HStack {
                SensorIndicator(
                    icon: "arrow.up.and.down",
                    label: "Accel",
                    active: accelerometer != nil
                )
                
                SensorIndicator(
                    icon: "rotate.3d",
                    label: "Gyro",
                    active: gyro != nil
                )
                
                SensorIndicator(
                    icon: "location.north",
                    label: "Compass",
                    active: true
                )
            }
        }
        .padding()
        .background(Color(.systemGray6))
        .cornerRadius(12)
    }
}

struct SensorIndicator: View {
    let icon: String
    let label: String
    let active: Bool
    
    var body: some View {
        VStack {
            Image(systemName: icon)
                .foregroundColor(active ? .green : .gray)
            Text(label)
                .font(.caption2)
                .foregroundColor(.secondary)
        }
        .frame(maxWidth: .infinity)
    }
}

// MARK: - Camera View

struct CameraView: UIViewControllerRepresentable {
    let onCapture: (UIImage) -> Void
    
    func makeUIViewController(context: Context) -> UIImagePickerController {
        let picker = UIImagePickerController()
        picker.sourceType = .camera
        picker.delegate = context.coordinator
        return picker
    }
    
    func updateUIViewController(_ uiViewController: UIImagePickerController, context: Context) {}
    
    func makeCoordinator() -> Coordinator {
        Coordinator(onCapture: onCapture)
    }
    
    class Coordinator: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
        let onCapture: (UIImage) -> Void
        
        init(onCapture: @escaping (UIImage) -> Void) {
            self.onCapture = onCapture
        }
        
        func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
            if let image = info[.originalImage] as? UIImage {
                onCapture(image)
            }
            picker.dismiss(animated: true)
        }
        
        func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
            picker.dismiss(animated: true)
        }
    }
}