import CoreLocation

class LocationManager: NSObject, CLLocationManagerDelegate {
    
    // CLLocationManager 인스턴스 생성
    private let locationManager = CLLocationManager()
    
    override init() {
        super.init()
        // 델리게이트 설정 - 위치 업데이트를 받을 객체 지정
        locationManager.delegate = self
        // 위치 정확도 설정 (배터리 vs 정밀도 트레이드오프)
        locationManager.desiredAccuracy = kCLLocationAccuracyBest
        // 최소 이동 거리 설정 (미터 단위) - 이 거리 이상 움직여야 업데이트
        locationManager.distanceFilter = 10.0
    }
    
    // 위치 권한 요청
    func requestPermission() {
        locationManager.requestWhenInUseAuthorization()
    }
    
    // 위치 업데이트 시작
    func startUpdating() {
        locationManager.startUpdatingLocation()
    }
    
    // 위치 업데이트 중지
    func stopUpdating() {
        locationManager.stopUpdatingLocation()
    }
}

// 권한 상태 변화 감지 (iOS 14+)
func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
    switch manager.authorizationStatus {
    case .notDetermined:
        // 아직 결정 안 됨 - 권한 요청
        manager.requestWhenInUseAuthorization()
    case .authorizedWhenInUse:
        // 앱 사용 중 허용 - 위치 업데이트 시작 가능
        manager.startUpdatingLocation()
    case .authorizedAlways:
        // 항상 허용 - 백그라운드 위치도 가능
        manager.startUpdatingLocation()
    case .denied:
        // 거부됨 - 설정 앱으로 유도
        print("위치 권한이 거부되었습니다. 설정에서 변경해주세요.")
    case .restricted:
        // 시스템 제한 (자녀 보호 등)
        print("위치 서비스가 제한되어 있습니다.")
    @unknown default:
        break
    }
}

// 위치 업데이트 수신 델리게이트 메서드
func locationManager(_ manager: CLLocationManager,
                     didUpdateLocations locations: [CLLocation]) {
    // 가장 최근 위치 가져오기
    guard let location = locations.last else { return }
    
    let latitude = location.coordinate.latitude
    let longitude = location.coordinate.longitude
    let accuracy = location.horizontalAccuracy
    let speed = location.speed  // m/s
    let altitude = location.altitude
    
    // 정확도 필터링 - 너무 부정확한 데이터는 무시
    // horizontalAccuracy가 음수면 유효하지 않은 데이터
    guard accuracy > 0 && accuracy < 100 else { return }
    
    print("위치: \(latitude), \(longitude)")
    print("정확도: \(accuracy)m")
    print("속도: \(speed * 3.6)km/h")  // m/s → km/h 변환
}

// 위치 오류 처리
func locationManager(_ manager: CLLocationManager,
                     didFailWithError error: Error) {
    if let clError = error as? CLError {
        switch clError.code {
        case .denied:
            print("위치 접근 거부됨")
        case .locationUnknown:
            print("위치를 일시적으로 알 수 없음")
        default:
            print("위치 오류: \(clError.localizedDescription)")
        }
    }
}

// 지오펜스 영역 설정
func setupGeofence() {
    // 모니터링할 중심 좌표 (예: 서울 시청)
    let center = CLLocationCoordinate2D(latitude: 37.5665, longitude: 126.9780)
    
    // 원형 영역 생성 (반경 200미터)
    let region = CLCircularRegion(
        center: center,
        radius: 200.0,  // 미터 단위
        identifier: "서울시청_영역"
    )
    
    // 진입/이탈 이벤트 설정
    region.notifyOnEntry = true   // 진입 시 알림
    region.notifyOnExit = true    // 이탈 시 알림
    
    // 모니터링 시작
    locationManager.startMonitoring(for: region)
}

// 영역 진입 감지
func locationManager(_ manager: CLLocationManager,
                     didEnterRegion region: CLRegion) {
    print("영역 진입: \(region.identifier)")
    // 푸시 알림 발송 등의 로직
    sendLocalNotification(title: "도착!", body: "서울시청 근처에 도착했어요!")
}

// 영역 이탈 감지
func locationManager(_ manager: CLLocationManager,
                     didExitRegion region: CLRegion) {
    print("영역 이탈: \(region.identifier)")
}

// 지오펜스 제한사항
// - 기기당 최대 20개 영역 동시 모니터링 가능
// - 최소 반경: 100미터 (실제로는 더 클 수 있음)
// - Always 권한 필요 (백그라운드 동작)

import MapKit

class MapViewController: UIViewController, MKMapViewDelegate {
    
    @IBOutlet weak var mapView: MKMapView!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // 델리게이트 설정
        mapView.delegate = self
        
        // 지도 타입 설정
        mapView.mapType = .standard        // 기본 지도
        // mapView.mapType = .satellite    // 위성 사진
        // mapView.mapType = .hybrid       // 위성 + 도로
        // mapView.mapType = .hybridFlyover // 3D 위성
        
        // 사용자 위치 표시 (파란 점)
        mapView.showsUserLocation = true
        
        // 나침반 표시
        mapView.showsCompass = true
        
        // 축척 표시
        mapView.showsScale = true
        
        // 교통 정보 표시
        mapView.showsTraffic = true
        
        // 건물 3D 표시
        mapView.showsBuildings = true
        
        // 초기 지도 영역 설정 (서울 중심)
        let seoulCenter = CLLocationCoordinate2D(
            latitude: 37.5665,
            longitude: 126.9780
        )
        let span = MKCoordinateSpan(
            latitudeDelta: 0.05,   // 위도 범위 (작을수록 확대)
            longitudeDelta: 0.05   // 경도 범위
        )
        let region = MKCoordinateRegion(center: seoulCenter, span: span)
        mapView.setRegion(region, animated: true)
    }
}

// 커스텀 어노테이션 모델 정의
class CustomAnnotation: NSObject, MKAnnotation {
    var coordinate: CLLocationCoordinate2D
    var title: String?
    var subtitle: String?
    var category: String  // 카테고리 (카페, 식당 등)
    
    init(coordinate: CLLocationCoordinate2D,
         title: String,
         subtitle: String,
         category: String) {
        self.coordinate = coordinate
        self.title = title
        self.subtitle = subtitle
        self.category = category
    }
}

// 어노테이션 추가
func addAnnotations() {
    let places = [
        ("스타벅스 강남점", "서울 강남구", 37.4979, 127.0276, "카페"),
        ("맥도날드 홍대점", "서울 마포구", 37.5563, 126.9236, "패스트푸드"),
        ("국립중앙박물관", "서울 용산구", 37.5236, 126.9803, "문화")
    ]
    
    for place in places {
        let annotation = CustomAnnotation(
            coordinate: CLLocationCoordinate2D(
                latitude: place.2,
                longitude: place.3
            ),
            title: place.0,
            subtitle: place.1,
            category: place.4
        )
        mapView.addAnnotation(annotation)
    }
}

// 어노테이션 뷰 커스터마이징
func mapView(_ mapView: MKMapView,
             viewFor annotation: MKAnnotation) -> MKAnnotationView? {
    // 사용자 위치 어노테이션은 기본 뷰 사용
    guard let customAnnotation = annotation as? CustomAnnotation else {
        return nil
    }
    
    let identifier = "CustomPin"
    var annotationView = mapView.dequeueReusableAnnotationView(
        withIdentifier: identifier
    ) as? MKMarkerAnnotationView
    
    if annotationView == nil {
        annotationView = MKMarkerAnnotationView(
            annotation: customAnnotation,
            reuseIdentifier: identifier
        )
        annotationView?.canShowCallout = true  // 탭 시 말풍선 표시
    } else {
        annotationView?.annotation = customAnnotation
    }
    
    // 카테고리별 색상 설정
    switch customAnnotation.category {
    case "카페":
        annotationView?.markerTintColor = .brown
        annotationView?.glyphText = "☕"
    case "패스트푸드":
        annotationView?.markerTintColor = .red
        annotationView?.glyphText = "🍔"
    case "문화":
        annotationView?.markerTintColor = .purple
        annotationView?.glyphText = "🏛️"
    default:
        annotationView?.markerTintColor = .blue
    }
    
    return annotationView
}

// 원형 오버레이 (지오펜스 시각화)
func addCircleOverlay() {
    let center = CLLocationCoordinate2D(latitude: 37.5665, longitude: 126.9780)
    let circle = MKCircle(center: center, radius: 500)  // 반경 500m
    mapView.addOverlay(circle)
}

// 경로 선 오버레이
func addPolylineOverlay() {
    var coordinates = [
        CLLocationCoordinate2D(latitude: 37.5665, longitude: 126.9780),
        CLLocationCoordinate2D(latitude: 37.5700, longitude: 126.9820),
        CLLocationCoordinate2D(latitude: 37.5750, longitude: 126.9900)
    ]
    let polyline = MKPolyline(coordinates: &coordinates, count: coordinates.count)
    mapView.addOverlay(polyline)
}

// 다각형 오버레이
func addPolygonOverlay() {
    var coordinates = [
        CLLocationCoordinate2D(latitude: 37.56, longitude: 126.97),
        CLLocationCoordinate2D(latitude: 37.57, longitude: 126.97),
        CLLocationCoordinate2D(latitude: 37.57, longitude: 126.99),
        CLLocationCoordinate2D(latitude: 37.56, longitude: 126.99)
    ]
    let polygon = MKPolygon(coordinates: &coordinates, count: coordinates.count)
    mapView.addOverlay(polygon)
}

// 오버레이 렌더러 설정 (델리게이트)
func mapView(_ mapView: MKMapView,
             rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
    if let circle = overlay as? MKCircle {
        let renderer = MKCircleRenderer(circle: circle)
        renderer.fillColor = UIColor.blue.withAlphaComponent(0.1)
        renderer.strokeColor = .blue
        renderer.lineWidth = 2
        return renderer
    }
    if let polyline = overlay as? MKPolyline {
        let renderer = MKPolylineRenderer(polyline: polyline)
        renderer.strokeColor = .systemBlue
        renderer.lineWidth = 4
        renderer.lineDashPattern = [8, 4]  // 점선 패턴
        return renderer
    }
    if let polygon = overlay as? MKPolygon {
        let renderer = MKPolygonRenderer(polygon: polygon)
        renderer.fillColor = UIColor.green.withAlphaComponent(0.15)
        renderer.strokeColor = .green
        renderer.lineWidth = 2
        return renderer
    }
    return MKOverlayRenderer(overlay: overlay)
}

// 역지오코딩 - 좌표 → 주소
func reverseGeocode(location: CLLocation) {
    let geocoder = CLGeocoder()
    
    geocoder.reverseGeocodeLocation(location) { placemarks, error in
        if let error = error {
            print("역지오코딩 실패: \(error.localizedDescription)")
            return
        }
        
        guard let placemark = placemarks?.first else { return }
        
        // 주소 구성 요소
        let country = placemark.country ?? ""           // 국가: 대한민국
        let administrativeArea = placemark.administrativeArea ?? ""  // 시/도: 서울특별시
        let locality = placemark.locality ?? ""         // 시/군/구: 중구
        let subLocality = placemark.subLocality ?? ""   // 동/읍/면: 명동
        let thoroughfare = placemark.thoroughfare ?? "" // 도로명
        let subThoroughfare = placemark.subThoroughfare ?? "" // 번지
        
        let address = "\(country) \(administrativeArea) \(locality) \(subLocality)"
        print("주소: \(address)")
    }
}

// 지오코딩 - 주소 → 좌표
func geocodeAddress(address: String) {
    let geocoder = CLGeocoder()
    
    geocoder.geocodeAddressString(address) { placemarks, error in
        if let error = error {
            print("지오코딩 실패: \(error.localizedDescription)")
            return
        }
        
        guard let placemark = placemarks?.first,
              let location = placemark.location else { return }
        
        let coordinate = location.coordinate
        print("좌표: \(coordinate.latitude), \(coordinate.longitude)")
        
        // 지도에 어노테이션 추가
        let annotation = MKPointAnnotation()
        annotation.coordinate = coordinate
        annotation.title = address
        self.mapView.addAnnotation(annotation)
    }
}

// 현재 위치 기반 주변 카페 검색
func searchNearbyPlaces(coordinate: CLLocationCoordinate2D, query: String) {
    let request = MKLocalSearch.Request()
    request.naturalLanguageQuery = query  // "카페", "편의점", "주유소" 등
    
    // 검색 반경 설정 (현재 위치 중심 1km 반경)
    let region = MKCoordinateRegion(
        center: coordinate,
        latitudinalMeters: 1000,
        longitudinalMeters: 1000
    )
    request.region = region
    
    // 결과 타입 필터 (iOS 13+)
    request.resultTypes = [.pointOfInterest, .address]
    
    let search = MKLocalSearch(request: request)
    search.start { response, error in
        if let error = error {
            print("검색 실패: \(error.localizedDescription)")
            return
        }
        
        guard let response = response else { return }
        
        // 기존 어노테이션 제거
        self.mapView.removeAnnotations(self.mapView.annotations)
        
        // 검색 결과 처리
        for item in response.mapItems {
            let annotation = MKPointAnnotation()
            annotation.coordinate = item.placemark.coordinate
            annotation.title = item.name
            annotation.subtitle = item.placemark.thoroughfare
            self.mapView.addAnnotation(annotation)
            
            // 추가 정보
            print("장소명: \(item.name ?? "")")
            print("전화번호: \(item.phoneNumber ?? "")")
            print("URL: \(item.url?.absoluteString ?? "")")
            print("카테고리: \(item.pointOfInterestCategory?.rawValue ?? "")")
        }
        
        // 검색 결과가 보이도록 지도 영역 조정
        self.mapView.showAnnotations(self.mapView.annotations, animated: true)
    }
}

// 경로 계산 및 표시
func calculateRoute(from source: CLLocationCoordinate2D,
                    to destination: CLLocationCoordinate2D) {
    // 출발지 설정
    let sourcePlacemark = MKPlacemark(coordinate: source)
    let sourceMapItem = MKMapItem(placemark: sourcePlacemark)
    
    // 목적지 설정
    let destinationPlacemark = MKPlacemark(coordinate: destination)
    let destinationMapItem = MKMapItem(placemark: destinationPlacemark)
    
    // 경로 요청 설정
    let request = MKDirections.Request()
    request.source = sourceMapItem
    request.destination = destinationMapItem
    request.transportType = .automobile  // 자동차 경로
    // .walking  — 도보
    // .transit  — 대중교통
    // .any      — 모든 수단
    request.requestsAlternateRoutes = true  // 대안 경로도 요청
    
    let directions = MKDirections(request: request)
    directions.calculate { response, error in
        if let error = error {
            print("경로 계산 실패: \(error.localizedDescription)")
            return
        }
        
        guard let response = response else { return }
        
        // 기존 오버레이 제거
        self.mapView.removeOverlays(self.mapView.overlays)
        
        // 첫 번째 경로 (최적 경로) 표시
        if let route = response.routes.first {
            self.mapView.addOverlay(route.polyline, level: .aboveRoads)
            
            // 경로 정보 출력
            let distance = route.distance / 1000  // km
            let time = route.expectedTravelTime / 60  // 분
            print("거리: \(String(format: "%.1f", distance))km")
            print("예상 시간: \(Int(time))분")
            
            // 경로가 보이도록 지도 조정
            let rect = route.polyline.boundingMapRect
            self.mapView.setVisibleMapRect(
                rect,
                edgePadding: UIEdgeInsets(top: 50, left: 50, bottom: 50, right: 50),
                animated: true
            )
            
            // 턴바이턴 안내 정보
            for step in route.steps {
                print("안내: \(step.instructions)")
                print("거리: \(step.distance)m")
            }
        }
    }
}

// 경로 오버레이 렌더러 (델리게이트에 추가)
// func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
//     if let polyline = overlay as? MKPolyline {
//         let renderer = MKPolylineRenderer(polyline: polyline)
//         renderer.strokeColor = .systemBlue
//         renderer.lineWidth = 5
//         return renderer
//     }
//     return MKOverlayRenderer(overlay: overlay)
// }

// 사용자 위치 추적 모드 설정
func setupUserTracking() {
    // 사용자 위치를 지도 중심으로 자동 추적
    mapView.userTrackingMode = .follow
    // .none          — 추적 안 함
    // .follow        — 위치 추적 (방향 고정)
    // .followWithHeading — 위치 + 방향 추적 (나침반 방향으로 회전)
}

// 위치 업데이트 시 지도 중심 이동
func locationManager(_ manager: CLLocationManager,
                     didUpdateLocations locations: [CLLocation]) {
    guard let location = locations.last,
          location.horizontalAccuracy > 0 else { return }
    
    // 처음 위치 수신 시에만 지도 중심 이동
    if isFirstLocationUpdate {
        let region = MKCoordinateRegion(
            center: location.coordinate,
            latitudinalMeters: 500,
            longitudinalMeters: 500
        )
        mapView.setRegion(region, animated: true)
        isFirstLocationUpdate = false
    }
    
    // 현재 위치 저장
    currentLocation = location
    
    // 이동 경로 기록 (러닝 앱 등에서 활용)
    routeCoordinates.append(location.coordinate)
    updateRouteOverlay()
}

// 이동 경로 실시간 업데이트
private var routeCoordinates: [CLLocationCoordinate2D] = []

func updateRouteOverlay() {
    // 기존 경로 오버레이 제거
    let existingOverlays = mapView.overlays.filter { $0 is MKPolyline }
    mapView.removeOverlays(existingOverlays)
    
    // 새 경로 오버레이 추가
    if routeCoordinates.count >= 2 {
        var coords = routeCoordinates
        let polyline = MKPolyline(coordinates: &coords, count: coords.count)
        mapView.addOverlay(polyline, level: .aboveRoads)
    }
}

// 1. Xcode 프로젝트 설정
// Target → Signing & Capabilities → Background Modes
// ✅ Location updates 체크

// 2. Info.plist에 추가
// NSLocationAlwaysAndWhenInUseUsageDescription
// NSLocationAlwaysUsageDescription

// 3. 코드 설정
func setupBackgroundLocationUpdates() {
    // Always 권한 요청 (백그라운드 위치에 필수)
    locationManager.requestAlwaysAuthorization()
    
    // 백그라운드 위치 업데이트 허용
    locationManager.allowsBackgroundLocationUpdates = true
    
    // 일시 정지 자동 허용 (배터리 절약)
    // true: 시스템이 배터리 절약을 위해 자동으로 일시 정지 가능
    locationManager.pausesLocationUpdatesAutomatically = false
    
    // 중요 위치 변경 모니터링 (배터리 효율적)
    // 셀 타워 변경 시에만 업데이트 (약 500m~수km 단위)
    locationManager.startMonitoringSignificantLocationChanges()
}

// 앱이 백그라운드에서 종료된 후 재실행될 때
// AppDelegate에서 처리
func application(_ application: UIApplication,
                 didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    
    // 위치 업데이트로 인해 재실행된 경우
    if let _ = launchOptions?[.location] {
        // LocationManager 재초기화 및 업데이트 재시작
        locationManager.startMonitoringSignificantLocationChanges()
    }
    return true
}

<!-- GPX 파일 예시 (Seoul_Route.gpx) -->
<?xml version="1.0" encoding="UTF-8"?>
<gpx version="1.1" creator="Xcode">
    <trk>
        <name>서울 테스트 경로</name>
        <trkseg>
            <trkpt lat="37.5665" lon="126.9780">
                <ele>38</ele>
                <time>2024-01-01T09:00:00Z</time>
            </trkpt>
            <trkpt lat="37.5680" lon="126.9800">
                <ele>40</ele>
                <time>2024-01-01T09:00:30Z</time>
            </trkpt>
            <trkpt lat="37.5700" lon="126.9830">
                <ele>42</ele>
                <time>2024-01-01T09:01:00Z</time>
            </trkpt>
        </trkseg>
    </trk>
</gpx>

// GPX 파일 사용법:
// 1. Xcode 프로젝트에 GPX 파일 추가
// 2. Edit Scheme → Run → Options → Default Location → GPX 파일 선택
// 3. 앱 실행 시 GPX 경로대로 위치가 변함

import SwiftUI
import MapKit

// iOS 17+ SwiftUI Map
struct ContentView: View {
    // 지도 카메라 위치 상태
    @State private var cameraPosition: MapCameraPosition = .region(
        MKCoordinateRegion(
            center: CLLocationCoordinate2D(latitude: 37.5665, longitude: 126.9780),
            span: MKCoordinateSpan(latitudeDelta: 0.05, longitudeDelta: 0.05)
        )
    )
    
    // 선택된 장소
    @State private var selectedPlace: MKMapItem?
    
    // 검색 결과
    @State private var searchResults: [MKMapItem] = []
    
    var body: some View {
        Map(position: $cameraPosition, selection: $selectedPlace) {
            // 사용자 위치 표시
            UserAnnotation()
            
            // 검색 결과 마커 표시
            ForEach(searchResults, id: \.self) { item in
                Marker(item: item)
                    .tint(.blue)
            }
            
            // 커스텀 어노테이션
            Annotation("서울시청", coordinate: CLLocationCoordinate2D(
                latitude: 37.5665, longitude: 126.9780
            )) {
                ZStack {
                    Circle()
                        .fill(.blue)
                        .frame(width: 40, height: 40)
                    Image(systemName: "building.2")
                        .foregroundColor(.white)
                }
            }
        }
        .mapStyle(.standard(elevation: .realistic))  // 3D 지형
        .mapControls {
            MapUserLocationButton()  // 내 위치 버튼
            MapCompass()             // 나침반
            MapScaleView()           // 축척
        }
        .onChange(of: selectedPlace) { _, newValue in
            if let place = newValue {
                print("선택된 장소: \(place.name ?? "")")
            }
        }
    }
}

// iOS 17+ 위치 관리 (Observable)
@Observable
class LocationService: NSObject, CLLocationManagerDelegate {
    private let manager = CLLocationManager()
    var currentLocation: CLLocation?
    var authorizationStatus: CLAuthorizationStatus = .notDetermined
    
    override init() {
        super.init()
        manager.delegate = self
        manager.desiredAccuracy = kCLLocationAccuracyBest
    }
    
    func requestPermission() {
        manager.requestWhenInUseAuthorization()
    }
    
    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
        authorizationStatus = manager.authorizationStatus
        if authorizationStatus == .authorizedWhenInUse {
            manager.startUpdatingLocation()
        }
    }
    
    func locationManager(_ manager: CLLocationManager,
                         didUpdateLocations locations: [CLLocation]) {
        currentLocation = locations.last
    }
}

// 배터리 최적화를 위한 적응형 위치 업데이트
class AdaptiveLocationManager: NSObject, CLLocationManagerDelegate {
    private let manager = CLLocationManager()
    private var isMoving = false
    
    // 이동 중일 때와 정지 중일 때 다른 설정 적용
    func updateAccuracyBasedOnMovement(speed: Double) {
        if speed > 1.0 {  // 1m/s 이상 = 이동 중
            if !isMoving {
                isMoving = true
                // 이동 중: 높은 정확도
                manager.desiredAccuracy = kCLLocationAccuracyBest
                manager.distanceFilter = 5  // 5m마다 업데이트
            }
        } else {  // 정지 중
            if isMoving {
                isMoving = false
                // 정지 중: 낮은 정확도로 배터리 절약
                manager.desiredAccuracy = kCLLocationAccuracyHundredMeters
                manager.distanceFilter = 50  // 50m마다 업데이트
            }
        }
    }
    
    func locationManager(_ manager: CLLocationManager,
                         didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.last else { return }
        updateAccuracyBasedOnMovement(speed: location.speed)
    }
    
    // 앱이 백그라운드로 갈 때 배터리 절약 모드
    func applicationDidEnterBackground() {
        manager.desiredAccuracy = kCLLocationAccuracyKilometer
        manager.distanceFilter = 500
    }
    
    // 앱이 포그라운드로 올 때 정확도 복원
    func applicationWillEnterForeground() {
        manager.desiredAccuracy = kCLLocationAccuracyBest
        manager.distanceFilter = 10
    }
}

// 위치 튐 현상 필터링
func locationManager(_ manager: CLLocationManager,
                     didUpdateLocations locations: [CLLocation]) {
    guard let location = locations.last else { return }
    
    // 1. 정확도 필터 - 부정확한 데이터 무시
    guard location.horizontalAccuracy >= 0,
          location.horizontalAccuracy <= 65 else { return }
    
    // 2. 타임스탬프 필터 - 오래된 캐시 데이터 무시
    let age = -location.timestamp.timeIntervalSinceNow
    guard age < 5 else { return }  // 5초 이내 데이터만 사용
    
    // 3. 속도 필터 - 물리적으로 불가능한 속도 무시
    if let previousLocation = previousLocation {
        let distance = location.distance(from: previousLocation)
        let timeInterval = location.timestamp.timeIntervalSince(previousLocation.timestamp)
        let calculatedSpeed = distance / timeInterval
        
        // 시속 300km 이상이면 튐 현상으로 판단
        guard calculatedSpeed < 83.3 else { return }  // 300km/h = 83.3m/s
    }
    
    previousLocation = location
    // 유효한 위치 처리
    processValidLocation(location)
}

// 권한 거부 시 설정 앱으로 유도
func showLocationPermissionAlert() {
    let alert = UIAlertController(
        title: "위치 권한 필요",
        message: "이 기능을 사용하려면 위치 접근 권한이 필요합니다. 설정에서 권한을 허용해주세요.",
        preferredStyle: .alert
    )
    
    alert.addAction(UIAlertAction(title: "취소", style: .cancel))
    alert.addAction(UIAlertAction(title: "설정으로 이동", style: .default) { _ in
        // 앱 설정 화면으로 이동
        if let settingsURL = URL(string: UIApplication.openSettingsURLString) {
            UIApplication.shared.open(settingsURL)
        }
    })
    
    present(alert, animated: true)
}

// 권한 상태 확인 후 적절한 처리
func checkAndRequestPermission() {
    switch locationManager.authorizationStatus {
    case .notDetermined:
        locationManager.requestWhenInUseAuthorization()
    case .denied, .restricted:
        showLocationPermissionAlert()
    case .authorizedWhenInUse, .authorizedAlways:
        locationManager.startUpdatingLocation()
    @unknown default:
        break
    }
}