//
//  MapView.swift
//  TestGeoJSON
//
//  Created by Alin Fusaru on 02.03.2022.
//

import SwiftUI
import MapKit

struct MapView: UIViewRepresentable {
    
    var tapCoordinates: Binding<CLLocationCoordinate2D>
    var polygonID: Binding<String>
    @EnvironmentObject var mapData: MapViewModel
    @State var restrictions: [MKOverlay] = []
    @State var restrictionsData: [RestrictionInfo] = []
    
    func makeCoordinator() -> Coordinator {
        return MapView.Coordinator(self, tapCoordinatesBinding: tapCoordinates, polygonTitle: polygonID)
    }
    
    func makeUIView(context: Context) -> MKMapView {
        
        mapData.mapView.delegate = context.coordinator
        
        let view = mapData.mapView
        
        
        view.showsUserLocation = true
        view.delegate = context.coordinator
        
        mapData.showRestrictedZones { (restriction) in
            self.restrictions = restriction
            view.addOverlays(self.restrictions)
        }
        return view
    }
    
    func updateUIView(_ uiView: MKMapView, context: Context) {
        
    }
    
    class Coordinator: NSObject, MKMapViewDelegate, UIGestureRecognizerDelegate {
        var parent: MapView
        var polygonTitle: Binding<String>
        var gRecognizer = UITapGestureRecognizer()
        
        var tapCoordinatesBinding: Binding<CLLocationCoordinate2D>
        var coordinate = CLLocationCoordinate2D()

        
        init(_ parent: MapView, tapCoordinatesBinding: Binding<CLLocationCoordinate2D>, polygonTitle: Binding<String>) {
            self.parent = parent
            self.tapCoordinatesBinding = tapCoordinatesBinding
            self.polygonTitle = polygonTitle
            super.init()
            self.gRecognizer = UITapGestureRecognizer(target: self, action: #selector(tapHandler))
            self.gRecognizer.delegate = self
            self.parent.mapData.mapView.addGestureRecognizer(gRecognizer)
        }
        
        
        @objc func tapHandler(_ gesture: UITapGestureRecognizer) {
            // position on the screen, CGPoint
            let location = gRecognizer.location(in: self.parent.mapData.mapView)
            // position on the map, CLLocationCoordinate2D
            coordinate = self.parent.mapData.mapView.convert(location, toCoordinateFrom: self.parent.mapData.mapView)
            tapCoordinatesBinding.wrappedValue = coordinate
            
            for overlay: MKOverlay in self.parent.mapData.mapView.overlays {
                if let polygon = overlay as? MKPolygon {
                    let renderer = MKPolygonRenderer(polygon: polygon)
                    let mapPoint = MKMapPoint(coordinate)
                    let rendererPoint = renderer.point(for: mapPoint)
                    if renderer.path.contains(rendererPoint) {
                        print("Tap inside polygon")
                        print("Polygon \(polygon.title ?? "no value") has been tapped")
                        polygonTitle.wrappedValue = polygon.title!
                    }
                }
            }
        }
        
        
        func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
            if let polygon = overlay as? MKPolygon {
                let renderer = MKPolygonRenderer(polygon: polygon)
                renderer.fillColor = UIColor.purple.withAlphaComponent(0.2)
                renderer.strokeColor = .purple.withAlphaComponent(0.7)
                renderer.lineWidth = 2
                
                return renderer
            }
            return MKOverlayRenderer(overlay: overlay)
        }
    }
}