Meshtastic-Apple/Meshtastic/Views/Settings/MapDataFiles.swift

import SwiftUI
import UniformTypeIdentifiers
import OSLog

struct MapDataFiles: View {
    @Environment(\.managedObjectContext) var context
    @EnvironmentObject var bleManager: BLEManager
    @ObservedObject private var mapDataManager = MapDataManager.shared

    @State private var isShowingFilePicker = false
    @State private var isProcessing = false
    @State private var processingProgress: Double = 0.0
    @State private var showError = false
    @State private var errorMessage = ""
    @State private var showSuccess = false
    @State private var successMessage = ""

    var body: some View {
        VStack(spacing: 20) {
            // Header
            VStack(alignment: .leading, spacing: 8) {
                                Text(NSLocalizedString("Upload Map Data", comment: "Title for map data upload screen"))
                    .font(.title2)
                    .fontWeight(.bold)

                Text("Upload GeoJSON files to display custom map overlays. Files are stored locally and can be up to 10MB.")
                    .font(.caption)
                    .foregroundColor(.secondary)
            }
            .frame(maxWidth: .infinity, alignment: .leading)
            .padding(.horizontal)

            // Upload Button
            Button(action: {
                isShowingFilePicker = true
            }) {
                HStack {
                    Image(systemName: "doc.badge.plus")
                        .font(.title2)
                    Text(NSLocalizedString("Select Map Data File", comment: "Button text for selecting map data file"))
                        .fontWeight(.medium)
                }
                .frame(maxWidth: .infinity)
                .padding()
                .background(Color.accentColor)
                .foregroundColor(.white)
                .cornerRadius(10)
            }
            .disabled(isProcessing)
            .padding(.horizontal)

            // Processing Indicator
            if isProcessing {
                VStack(spacing: 12) {
                    ProgressView(value: processingProgress)
                        .progressViewStyle(LinearProgressViewStyle())
                        .padding(.horizontal)

                    Text("Processing file...")
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }

            // Current Files Section
            VStack(alignment: .leading, spacing: 12) {
                Text(NSLocalizedString("Uploaded Files", comment: "Section header for uploaded files"))
                    .font(.headline)
                    .padding(.horizontal)

                let uploadedFiles = mapDataManager.getUploadedFiles()

                if uploadedFiles.isEmpty {
                    VStack(spacing: 8) {
                        Image(systemName: "doc.text")
                            .font(.title)
                            .foregroundColor(.secondary)
                        Text(NSLocalizedString("No files uploaded yet", comment: "Empty state text when no files are uploaded"))
                            .font(.caption)
                            .foregroundColor(.secondary)
                    }
                    .frame(maxWidth: .infinity)
                    .padding(.vertical, 40)
                } else {
                    ScrollView {
                        LazyVStack(spacing: 8) {
                            ForEach(uploadedFiles) { file in
                                MapDataFileRow(file: file) {
                                    deleteFile(file)
                                }
                            }
                        }
                        .padding(.horizontal)
                    }
                }
            }

            Spacer()
        }
        .navigationTitle("Map Data")
        .navigationBarTitleDisplayMode(.inline)
        .fileImporter(
            isPresented: $isShowingFilePicker,
            allowedContentTypes: [
                UTType.json,
                UTType(filenameExtension: "geojson") ?? UTType.json
            ],
            allowsMultipleSelection: false
        ) { result in
            handleFileSelection(result)
        }
        .alert("Upload Error", isPresented: $showError) {
            Button("OK") { }
        } message: {
            Text(errorMessage)
        }
        .alert("Upload Success", isPresented: $showSuccess) {
            Button("OK") { }
        } message: {
            Text(successMessage)
        }
        .onAppear {
            // Initialize map data manager if needed
            mapDataManager.initialize()
        }
    }

    // MARK: - File Handling

    private func handleFileSelection(_ result: Result<[URL], Error>) {
        do {
            guard let selectedFile = try result.get().first else { return }

            // Start processing
            isProcessing = true
            processingProgress = 0.0

            // Process file asynchronously
            Task {
                do {
                    // Simulate progress
                    await simulateProgress()

                    let metadata = try await mapDataManager.processUploadedFile(from: selectedFile)

                    await MainActor.run {
                        isProcessing = false
                        processingProgress = 1.0

                        successMessage = "Successfully uploaded '\(metadata.originalName)' with \(metadata.overlayCount) overlays"
                        showSuccess = true
                    }
                } catch {
                    await MainActor.run {
                        isProcessing = false
                        processingProgress = 0.0

                        errorMessage = error.localizedDescription
                        showError = true
                    }
                }
            }
        } catch {
            errorMessage = "Failed to access file: \(error.localizedDescription)"
            showError = true
        }
    }

    private func simulateProgress() async {
        for i in 1...10 {
            await MainActor.run {
                processingProgress = Double(i) / 10.0
            }
            try? await Task.sleep(nanoseconds: 200_000_000) // 0.2 seconds
        }
    }

    private func deleteFile(_ file: MapDataMetadata) {
        Task {
            do {
                try await mapDataManager.deleteFile(file)
            } catch {
                await MainActor.run {
                    errorMessage = "Failed to delete file: \(error.localizedDescription)"
                    showError = true
                }
            }
        }
    }
}

// MARK: - Supporting Views

struct MapDataFileRow: View {
    let file: MapDataMetadata
    let onDelete: () -> Void

    var body: some View {
        HStack {
            VStack(alignment: .leading, spacing: 4) {
                HStack {
                    Text(file.originalName)
                        .font(.headline)
                        .lineLimit(1)

                    Spacer()
                }

                HStack {
                    Text(file.format.uppercased())
                        .font(.caption)
                        .padding(.horizontal, 8)
                        .padding(.vertical, 2)
                        .background(Color.secondary.opacity(0.2))
                        .cornerRadius(4)

                    Text(file.fileSizeString)
                        .font(.caption)
                        .foregroundColor(.secondary)

                    Text("•")
                        .font(.caption)
                        .foregroundColor(.secondary)

                    Text("\(file.overlayCount) overlays")
                        .font(.caption)
                        .foregroundColor(.secondary)

                    Spacer()

                    Text(file.uploadDateString)
                        .font(.caption)
                        .foregroundColor(.secondary)
                }
            }

            Button(action: onDelete) {
                Image(systemName: "trash")
                    .foregroundColor(.red)
            }
            .buttonStyle(BorderlessButtonStyle())
        }
        .padding()
        .background(Color(.systemBackground))
        .cornerRadius(8)
        .shadow(color: .black.opacity(0.1), radius: 2, x: 0, y: 1)
    }
}

#Preview {
    NavigationView {
        MapDataFiles()
    }
}