.ignoresSafeArea(edges: .top, treatingAs: .edge)

.ignoresSafeArea(edges: .top, treatingAs: .edge) // <--- WRONG

ignoresSafeArea(edges: .top) // <--- CORRECT: Ignore top safe area

import SwiftUI
import MapKit
struct SearchableMap: View {
    // --- State Variables ---
    @State private var locationService = LocationService()
    @State private var position: MapCameraPosition = .automatic
    @State private var selectedResult: SearchResult?
    @State private var isSheetPresented: Bool = true
    @State private var showSearchButton: Bool = false
    @State private var lookAroundScene: MKLookAroundScene?
 
    // Computed property
    var searchResults: [SearchResult] { locationService.searchResults }
    var body: some View {
        Map(position: $position, selection: $selectedResult) {
            // Map content: Markers for search results
            ForEach(searchResults) { result in
                Marker(result.name, coordinate: result.location)
                    .tag(result)
            }
        }
        // --- Apply Modifiers Directly to Map ---
        .mapStyle(.standard(elevation: .realistic))
       
        // --- State Change Handlers ---
        .onChange(of: searchResults) { _, newResults in handleSearchResultsChange(newResults) }
        .onChange(of: selectedResult) { _, newValue in handleSelectionChange(newValue) }
        .task(id: selectedResult?.id) { await fetchLookAroundScene(for: selectedResult) } // Robust fetch
        // --- Search Button Overlay ---
        .overlay(alignment: .topTrailing) {
            // Use computed property for the button content
            searchButtonOverlay
        }
        // Apply animation specifically for the button's appearance/disappearance
        .animation(.easeInOut, value: showSearchButton)
       
        // --- Look Around Panel using safeAreaInset ---
        .safeAreaInset(edge: .bottom) {
            // Conditionally display the panel using the computed property
            lookAroundPanel // Ensures animation applies correctly
        }
        // --- Bottom Sheet Presentation ---
        .sheet(isPresented: $isSheetPresented, onDismiss: handleSheetDismiss) {
            // Use computed property for sheet content
            sheetContent
        }
        // --- Optional: Error Alert ---
        .alert("Location Service Error", isPresented: locationService.isErrorPresented, presenting: locationService.error) { _ in Button("OK") {} } message: { error in Text(error.localizedDescription) }
    } // End of body
    // MARK: - Computed Properties for Sub-Views (Helps Compiler)
    // Computed property for the Look Around Panel content
    @ViewBuilder
    private var lookAroundPanel: some View {
        if selectedResult != nil { // Condition checked here
            LookAroundPanelView(scene: $lookAroundScene, resultName: selectedResult?.name)
                .frame(height: 150) // Define size here
                .clipShape(RoundedRectangle(cornerRadius: 15))
                .background(.thinMaterial)
                .cornerRadius(15)
                .shadow(radius: 5)
                .padding(.horizontal) // Add horizontal padding
                .padding(.bottom, 10) // Add some padding from the absolute bottom edge
                .transition(.move(edge: .bottom).combined(with: .opacity)) // Animation transition
        }
    }
    // Computed property for the search button overlay content
    @ViewBuilder
    private var searchButtonOverlay: some View {
        if showSearchButton {
            Button {
                selectedResult = nil
                showSearchButton = false
                isSheetPresented = true
            } label: {
                Image(systemName: "magnifyingglass")
                    .font(.title2)
                    .padding(12)
                    .background(.thinMaterial, in: Circle())
                    .shadow(radius: 3)
            }
            .padding() // Padding from screen edges
            .transition(.scale.combined(with: .opacity))
        } else {
            EmptyView()
        }
    }
    // Computed property for the sheet's content view
    private var sheetContent: some View {
        SheetView(locationService: locationService)
            .presentationDetents([.height(250), .medium, .large])
            .presentationBackground(.regularMaterial)
            .presentationBackgroundInteraction(.enabled(upThrough: .medium))
            .presentationCornerRadius(15)
            // Optional: .interactiveDismissDisabled()
    }
    // MARK: - Helper Functions / Handlers (Keep As Is)
    private func handleSearchResultsChange(_ newResults: [SearchResult]) {
        if !newResults.isEmpty {
            isSheetPresented = false
            showSearchButton = true
           
            if newResults.count == 1 { selectedResult = newResults.first }
            if let region = locationService.region {
                withAnimation(.smooth(duration: 0.7)) { position = .region(region) }
            }
        } else {
            showSearchButton = false
        }
    }
    private func handleSelectionChange(_ newValue: SearchResult?) {
        print("Selected result changed to: \(newValue?.name ?? "None")")
        if newValue == nil && !isSheetPresented && !searchResults.isEmpty { showSearchButton = true }
   
        // Fetching handled by .task
    }
    private func handleSheetDismiss() {
        print("Sheet dismissed manually.")
        if !locationService.searchResults.isEmpty { showSearchButton = true }
    }
    private func fetchLookAroundScene(for result: SearchResult?) async {
        guard let result = result else {
                self.lookAroundScene = nil
            return
        }
        print("Fetching Look Around scene for \(result.name)...")
        let request = MKLookAroundSceneRequest(coordinate: result.location)
        do {
            let scene = try await request.scene
            self.lookAroundScene = scene
            //----
            isSheetPresented = false
            //----
            print("Look Around scene fetched successfully: \(scene != nil)")
        } catch {
            print("❌ Failed to fetch Look Around scene: \(error.localizedDescription)")
            self.lookAroundScene = nil
        }
    }
}
// MARK: - Extracted Look Around Panel View (Keep As Is)
struct LookAroundPanelView: View {
    @Binding var scene: MKLookAroundScene?
    var resultName: String?
    var body: some View {
        VStack(alignment: .leading, spacing: 5) {
            if let name = resultName {
                Text(name)
                    .font(.caption.weight(.semibold))
                    .padding(.horizontal, 8)
                    .padding(.top, 8)
            }
            LookAroundPreview(scene: $scene, allowsNavigation: true, badgePosition: .bottomTrailing)
        }
    }
}

// MARK: - Observable Extension for Alert Binding (Keep As Is)
extension LocationService {
    var isErrorPresented: Binding<Bool> {
        Binding(get: { self.error != nil }, set: { if !$0 { self.error = nil } })
    }
}
// MARK: - Preview
#Preview {
    SearchableMap()
}

import MapKit
import CoreLocation // Ensure CoreLocation is imported
// Represents a search suggestion
struct SearchCompletions: Identifiable {
    let id = UUID()
    let title: String
    let subTitle: String
    // We can store the original MKLocalSearchCompletion if needed for more complex actions later
    // let mapKitCompletion: MKLocalSearchCompletion
}
// Represents a pin/marker on the map
struct SearchResult: Identifiable, Hashable, Equatable {
    let id = UUID()
    let name: String
    let location: CLLocationCoordinate2D
    let mapItem: MKMapItem // Store the original map item
    // Conformance for Map selection and comparison
    static func == (lhs: SearchResult, rhs: SearchResult) -> Bool {
        lhs.id == rhs.id
    }
    func hash(into hasher: inout Hasher) {
        hasher.combine(id)
    }
}
@Observable // Use @Observable for modern Swift concurrency state management
class LocationService: NSObject, MKLocalSearchCompleterDelegate {
    private let completer: MKLocalSearchCompleter
    private var currentSearch: MKLocalSearch?
    // --- Published Properties (Observable updates views) ---
    var completions = [SearchCompletions]()
    var searchResults = [SearchResult]()
    var error: Error?
    var region: MKCoordinateRegion? // Optional region to focus the map
    // --- Initialization ---
    override init() {
        self.completer = MKLocalSearchCompleter()
        super.init()
        self.completer.delegate = self
        // Configure completer (optional: filter results, etc.)
        self.completer.resultTypes = [ .pointOfInterest]//[.address, .pointOfInterest]
        // Optionally filter by region if needed
        // self.completer.region = MKCoordinateRegion(.world)
    }
    // --- Public Methods ---
    func update(queryFragment: String) {
        // Reset previous results and errors on new query
        self.completions = []
        self.error = nil
        completer.queryFragment = queryFragment
    }
    // --- MKLocalSearchCompleterDelegate ---
    func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) {
        // Map completer results to our SearchCompletions struct
        self.completions = completer.results.map { completion in
            // Extracting title parts can be useful if subtitle is long
            // let title = completion.title
            // let subTitle = completion.subtitle
            .init(title: completion.title, subTitle: completion.subtitle /*, mapKitCompletion: completion */)
        }
        self.error = nil
    }
    func completer(_ completer: MKLocalSearchCompleter, didFailWithError error: Error) {
        print("❌ Completer failed with error: \(error.localizedDescription)")
        self.error = error
        self.completions = []
    }
    // --- Search Execution ---
    func search ( with query: String) async {
        // Ensure query isn't empty
        guard !query.isEmpty else {
            self.searchResults = []
            self.region = nil
            return
        }
        // Cancel any ongoing search
        currentSearch?.cancel()
        // Prepare the search request
        let request = MKLocalSearch.Request()
        request.naturalLanguageQuery = query
      // request.resultTypes = [.address, .pointOfInterest]
        request.resultTypes = [ .pointOfInterest]
        // You could bias search results towards the current map view region if desired
        // if let mapRegion = self.currentMapRegion { // Assuming you have a way to get the current map region
        //     request.region = mapRegion
        // }
        let search = MKLocalSearch(request: request)
        self.currentSearch = search
        self.error = nil // Reset error before search
        print("➡️ Performing search for: \(query)")
        do {
            let response = try await search.start()
            self.currentSearch = nil // Clear current search reference
            // Map MKMapItems to our SearchResult struct
            self.searchResults = response.mapItems.compactMap { mapItem in
                guard let location = mapItem.placemark.location?.coordinate else { return nil }
                return SearchResult(name: mapItem.name ?? "Unknown Place", location: location, mapItem: mapItem)
            }
            // Calculate a region encompassing all results
            self.region = calculateRegion(for: self.searchResults)
            print("✅ Search successful, found \(self.searchResults.count) results.")
        } catch {
            self.currentSearch = nil // Clear current search reference
            // Handle errors, including cancellation
            if let nsError = error as NSError?, nsError.code == NSUserCancelledError {
                print(" Canceled search.")
                // Don't necessarily clear results if cancelled due to new search starting
            } else if let mkError = error as? MKError, mkError.code == .placemarkNotFound {
                print("ℹ️ No results found for '\(query)'.")
                self.searchResults = []
                self.region = nil
                // Optionally set a specific "not found" error state instead of generic error
            } else {
                print("❌ Search failed with error: \(error.localizedDescription)")
                self.error = error
                self.searchResults = []
                self.region = nil
            }
        }
    }
    // Helper function to search based on a completion item
    func search(for completion: SearchCompletions) async {
        // Create a more specific query from the completion
        let query = "\(completion.title), \(completion.subTitle)"
        await search(with: query)
    }
    // --- Helper for calculating region ---
    private func calculateRegion(for results: [SearchResult]) -> MKCoordinateRegion? {
        guard !results.isEmpty else { return nil }
        if results.count == 1, let firstResult = results.first {
            // For a single result, center on it with a reasonable span
            return MKCoordinateRegion(center: firstResult.location, latitudinalMeters: 1000, longitudinalMeters: 1000) // 1km span
        } else {
            // For multiple results, calculate bounding box
            var minLat = 90.0
            var maxLat = -90.0
            var minLon = 180.0
            var maxLon = -180.0
            for result in results {
                let coord = result.location
                minLat = min(minLat, coord.latitude)
                maxLat = max(maxLat, coord.latitude)
                minLon = min(minLon, coord.longitude)
                maxLon = max(maxLon, coord.longitude)
            }
            let center = CLLocationCoordinate2D(latitude: (minLat + maxLat) / 2.0, longitude: (minLon + maxLon) / 2.0)
            let span = MKCoordinateSpan(latitudeDelta: (maxLat - minLat) * 1.4, longitudeDelta: (maxLon - minLon) * 1.4) // Add padding (* 1.4)
            return MKCoordinateRegion(center: center, span: span)
        }
    }
}

import SwiftUI
import MapKit
struct SheetView: View {
    // Use @Bindable for two-way binding with @Observable service
    @Bindable var locationService: LocationService
    @State private var search: String = ""
    // Environment variable to dismiss the sheet
    @Environment(\.dismiss) var dismiss
    var body: some View {
        VStack(spacing: 0) { // Use spacing 0 and add padding manually if needed
            // Search Bar Area
            HStack {
                Image(systemName: "magnifyingglass")
                    .foregroundColor(.secondary)
                TextField("Search for a place or address", text: $search)
                    .autocorrectionDisabled()
                    .onSubmit(performSearch) // Search when return key is pressed
            }
            .modifier(TextFieldGrayBackgroundColor()) // Apply custom style
            .padding()
            Divider()
            // List of Completions
            List {
                // Display suggestions if available
                ForEach(locationService.completions) { completion in
                    Button(action: { didTapOnCompletion(completion) }) {
                        VStack(alignment: .leading, spacing: 4) {
                            Text(completion.title)
                                .font(.headline)
                                .foregroundColor(.primary) // Ensure text is readable
                            Text(completion.subTitle)
                                .font(.subheadline)
                                .foregroundColor(.secondary)
                        }
                    }
                    .listRowBackground(Color.clear) // Optional: Make background transparent
                }
                // Show message if query entered but no completions
                if !search.isEmpty && locationService.completions.isEmpty && locationService.error == nil {
                    ContentUnavailableView.search(text: search)
                        // .listRowBackground(Color.clear) // Match background if needed
                }
            }
            .listStyle(.plain)
            .scrollContentBackground(.hidden) // Hide default list background
        }
        // Update completions live as the user types
        .onChange(of: search) { _, newValue in
            locationService.update(queryFragment: newValue)
        }
        // You might want to add error display within the sheet too
        .alert("Search Error", isPresented: Binding(get: { locationService.error != nil }, set: { _ in locationService.error = nil }), presenting: locationService.error) { _ in
            Button("OK") {}
        } message: { error in
            Text(error.localizedDescription)
        }
    }
    // MARK: - Actions
    private func performSearch() {
        guard !search.isEmpty else { return }
        Task {
            await locationService.search(with: search)
            // Sheet dismissal is now handled by SearchableMap's onChange(of: searchResults)
        }
    }
    private func didTapOnCompletion(_ completion: SearchCompletions) {
        Task {
            await locationService.search(for: completion)
            // Sheet dismissal is now handled by SearchableMap's onChange(of: searchResults)
        }
    }
}
// MARK: - View Modifier for Text Field Style
struct TextFieldGrayBackgroundColor: ViewModifier {
    func body(content: Content) -> some View {
        content
            .padding(12)
            .background(Color(.systemGray6)) // Use semantic colors
            .cornerRadius(10) // Slightly rounder corners
            .foregroundColor(.primary)
    }
}