class MetaGlassesService: ObservableObject {
    static let shared = MetaGlassesService()

    @Published var isConnected = false
    @Published var isSessionActive = false
    @Published var errorMessage: String?

    private(set) var streamSession: StreamSession?

    // MARK: - Connection with retry for Bluetooth discovery
    func connect() async throws {
        let wearables = Wearables.shared

        // Check registration state — skip if already registered
        var alreadyRegistered = false
        for await state in wearables.registrationStateStream() {
            alreadyRegistered = (state == .registered)
            break
        }

        if !alreadyRegistered {
            try await wearables.startRegistration()
            for await state in wearables.registrationStateStream() {
                if state == .registered { break }
            }
        }

        // Retry camera permission (Bluetooth discovery needs time)
        let maxRetries = 5
        for attempt in 1...maxRetries {
            do {
                let status = try await wearables.requestPermission(.camera)
                if status == .granted { break }
                throw MetaGlassesError.permissionDenied
            } catch {
                if attempt < maxRetries {
                    try? await Task.sleep(nanoseconds: 2_000_000_000)
                } else { throw error }
            }
        }

        // Wait for glasses to appear
        for await devices in wearables.devicesStream() {
            if !devices.isEmpty { break }
        }
        await MainActor.run { self.isConnected = true }
    }

    // MARK: - Stream Session
    func startSession() async throws {
        let config = StreamSessionConfig(
            videoCodec: .raw, resolution: .low, frameRate: 15
        )
        let session = StreamSession(
            streamSessionConfig: config,
            deviceSelector: AutoDeviceSelector(wearables: Wearables.shared)
        )
        self.streamSession = session
        await session.start()
    }

    // MARK: - Photo Capture
    func capturePhoto() async throws -> UIImage {
        guard let session = streamSession else {
            throw MetaGlassesError.noActiveSession
        }
        return try await withCheckedThrowingContinuation { continuation in
            var resumed = false
            let token = session.photoDataPublisher.listen { photoData in
                guard !resumed else { return }
                resumed = true
                if let image = UIImage(data: photoData.data) {
                    continuation.resume(returning: image)
                } else {
                    continuation.resume(throwing: MetaGlassesError.connectionFailed)
                }
            }
            session.capturePhoto(format: .jpeg)
        }
    }
}

class ProductDetectionManager: ObservableObject {
    static let shared = ProductDetectionManager()

    @Published var galleryItems: [GalleryItem] = []

    /// Add a captured image and immediately kick off upload
    func captureAndUpload(image: UIImage, token: String?) {
        let item = GalleryItem(image: image)
        DispatchQueue.main.async {
            self.galleryItems.insert(item, at: 0)
        }
        Task { await upload(item: item, token: token) }
    }

    private func upload(item: GalleryItem, token: String?) async {
        await MainActor.run { item.uploadStatus = .uploading }
        do {
            let response = try await ProductDetectionService.shared
                .detectProduct(image: item.image, token: token)
            if response.success {
                let result = ProductDetectionResult(from: response, image: item.image)
                await MainActor.run {
                    item.detectionResult = result
                    item.uploadStatus = .success
                }
            } else {
                let reason = response.reason ?? response.error ?? "Detection failed"
                await MainActor.run { item.uploadStatus = .failed(reason) }
            }
        } catch {
            await MainActor.run { item.uploadStatus = .failed(error.localizedDescription) }
        }
    }
}

func detectProduct(image: UIImage, token: String?) async throws -> ProductDetectionResponse {
    // Compress aggressively for fast upload
    guard let imageData = image.jpegData(compressionQuality: 0.5) else {
        throw ProductDetectionError.compressionFailed
    }

    // Resize if still too large
    var finalData = imageData
    if imageData.count > 2_000_000 {
        if let resized = resizeImage(image, maxDimension: 1024),
           let data = resized.jpegData(compressionQuality: 0.5) {
            finalData = data
        }
    }

    let boundary = UUID().uuidString
    var request = URLRequest(url: URL(string: "\(APIConfig.baseURL)/ai-product-detection/detect")!)
    request.httpMethod = "POST"
    request.timeoutInterval = 60
    request.setValue(token, forHTTPHeaderField: "Authorization")
    request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")

    // Build multipart body with image + reference ID
    var body = Data()
    body.append("--\(boundary)\r\n".data(using: .utf8)!)
    body.append("Content-Disposition: form-data; name=\"image\"; filename=\"capture.jpg\"\r\n".data(using: .utf8)!)
    body.append("Content-Type: image/jpeg\r\n\r\n".data(using: .utf8)!)
    body.append(finalData)
    body.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)
    request.httpBody = body

    let (data, _) = try await URLSession.shared.data(for: request)
    return try JSONDecoder().decode(ProductDetectionResponse.self, from: data)
}

struct ProductDetectionResponse: Codable {
    let success: Bool
    let modelName: String?
    let manufacturer: String?
    let description: String?
    let specs: SpecsValue?
    let qty: Int?
    let category: String?
    let potentialBuyerCount: Int?
    let potentialBuyers: [PotentialBuyer]?
    let imageUrl: String?
    let eBayAvgSalePrice: String?
    let mspAvgSalePrice: String?
    let reason: String?
    let error: String?
}

struct ProductDetectionResult: Identifiable {
    let id = UUID()
    let modelName: String
    let manufacturer: String
    let description: String
    let specs: String
    let qty: Int
    let category: String
    let potentialBuyerCount: Int
    let eBayAvgSalePrice: String
    let mspAvgSalePrice: String
    let capturedImage: UIImage?
}

import SwiftUI
import MWDATCore

@main
struct MSPDisposalApp: App {
    init() {
        AppTheme.registerFonts()
    }

    var body: some Scene {
        WindowGroup {
            SplashView()
                // Handle URL callbacks from Meta AI app for registration
                .onOpenURL { url in
                    Task {
                        do {
                            try await Wearables.shared.handleUrl(url)
                        } catch {
                            print("Failed to handle URL: \(error)")
                        }
                    }
                }
        }
    }
}

struct APIConfig {
    static let baseURL = "https://api.mspdisposal.com"

    struct Endpoints {
        static let signin = "/auth/signin"
        static let signup = "/auth/signup"
        static let detectProduct = "/ai-product-detection/detect"
        static let forgotPasswordMobile = "/admins/forgot-password-otp"
        static let verifyOTP = "/admins/verify-otp"
        static let resetPasswordMobile = "/admins/reset-password-otp"
    }

    static let timeoutInterval: TimeInterval = 30
}