eqn.ios/Sources/Earthquake Network/Controllers/Seismic Networks/SeismicNetworksMapDetailViewController.swift

//
//  SeismicNetworksMapDetailViewController.swift
//  Earthquake Network
//
//  Created by Andrea Busi on 21/02/21.
//  Copyright © 2021 Earthquake Network. All rights reserved.
//

import UIKit
import MapKit

protocol SeismicNetworksMapDetailViewControllerDelegate: class {
    func seismicNetworksMapDetailControllerWillUpdateData(_ controller: SeismicNetworksMapDetailViewController, needsDataUpdate: Bool)
}

class SeismicNetworksMapDetailViewController: EQNBaseMapViewController {

    // MARK: - State
    
    override var isFilterViewVisible: Bool {
        // a custom filter view id displayed
        true
    }
    weak var delegate: SeismicNetworksMapDetailViewControllerDelegate?
    
    // MARK: - UI
    
    override var filtersView: UIView {
        get { return seismicFiltersView }
        set { seismicFiltersView = newValue }
    }
    
    private lazy var seismicFiltersView: UIView = {
        let view = UIView()
        view.translatesAutoresizingMaskIntoConstraints = false
        view.backgroundColor = AppTheme.Colors.lightGray

        // label with current selecte filter
        view.addSubview(seismicsFilterLabel)
        seismicsFilterLabel.topAnchor.constraint(equalTo: view.topAnchor).isActive = true
        seismicsFilterLabel.bottomAnchor.constraint(equalTo: view.bottomAnchor).isActive = true
        seismicsFilterLabel.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 8.0).isActive = true
        seismicsFilterLabel.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -8.0).isActive = true
        
        // tap recognizer
        let tapRecognizer = UITapGestureRecognizer(target: self, action: #selector(filtersTapped(_:)))
        view.addGestureRecognizer(tapRecognizer)
        return view
    }()
    
    private lazy var seismicsFilterLabel: UILabel = {
        let label = UILabel()
        label.translatesAutoresizingMaskIntoConstraints = false
        label.textAlignment = .center
        label.text = ""
        return label
    }()
    
    // MARK: - Internal
    
    private let seismic: EQNSisma
    private var allSeismics: [EQNSisma]
    /// Contains circles drawed on the map
    private var mapCircles = [MKCircle]()
    
    // MARK: - Init
    
    init(seismic: EQNSisma, allSeismics: [EQNSisma]) {
        self.seismic = seismic
        self.allSeismics = allSeismics
        super.init()
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) is not available, please use init(seismic:allSeismics:)")
    }
    
    // MARK: - Public
    
    func updateSeismics(_ seismics: [EQNSisma]) {
        allSeismics = seismics
        loadDataSource()
    }
    
    override func registerMapAnnotationViews() {
        mapView.register(EQNCustomAnnotationView.self, forAnnotationViewWithReuseIdentifier: EQNCustomAnnotationView.DoubleLineIdentifier)
    }
    
    override func loadDataSource() {
        let annotations = allSeismics.map { EQNMapAnnotationSeismic(seismic: $0) }
        
        updateMap(with: annotations)
        
        // if the given seismic is still in the data source, show circles
        // otherwise just remove any other circles already on the map
        if allSeismics.contains(seismic) {
            addCircles(for: seismic.coordinate)
        } else {
            addCircles(for: nil)
        }
        
        loadFiltersRecap()
    }
    
    override func elaborateMapCenter() {
        setMapCenter(for: seismic.coordinate)
    }
    
    override func didTapAnnotation(_ annotation: MKAnnotation) {
        guard let annotation = annotation as? EQNMapAnnotationSeismic else { return }
        
        let viewModel = SeismicNetworkViewModel(seismic: annotation.seismic)
        
        let title = "\(viewModel.magnitude) - \(viewModel.place) - \(viewModel.network)"
        let message = ""
            + "📏 \(viewModel.depth)"
            + "\n⏱ \(viewModel.time)"
            + "\n📐 \(viewModel.distance)"
            + "\n🌍 \(viewModel.coordinate)"
            + "\n👨‍👩‍👦 \(viewModel.population)"
        
        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: NSLocalizedString("official_close", comment: ""), style: .cancel))
        present(alert, animated: true)
    }
    
    // MARK: - Private
    
    private func loadFiltersRecap() {
        let filters = FiltersViewModel()

        let recap = "\(NSLocalizedString("filter_filter", comment: "")): "
            + "M≥\(filters.magnitude) "
            + "D≤\(filters.distance) "
            + "T≤\(filters.timeframe)"
        seismicsFilterLabel.text = recap
    }
    
    private func addCircles(for location: CLLocation?) {
        // remove any previous circles
        mapView.removeOverlays(mapCircles)
        mapCircles.removeAll()
        
        // aggiungiamo 3 cerchi concentrici per il punto specificato (se disponibile)
        // li inseriamo a a 50, 100 e 200 km.
        guard let location = location else { return }
        
        let circles = [
            MKCircle(center: location.coordinate, radius: 25_000),
            MKCircle(center: location.coordinate, radius: 100_000),
            MKCircle(center: location.coordinate, radius: 200_000)
        ]
        
        // !!note: is important to assign here the circles
        // otherwise `addOverlays` will not work
        mapCircles = circles
        
        // creo nuovi cerchi
        mapView.addOverlays(circles)
    }
    
    // MARK: - Actions
    
    @objc override func filtersTapped(_ sender: UIGestureRecognizer) {
        let controller = SeismicFiltersViewController.makeController()
        controller.delegate = self
        controller.modalPresentationStyle = .overCurrentContext
        controller.modalTransitionStyle = .crossDissolve
        present(controller, animated: true, completion: nil)
    }
    
    // MARK: - Map
    
    override func setupAnnotationView(for annotation: MKAnnotation, on mapView: MKMapView) -> MKAnnotationView? {
        guard let annotation = annotation as? EQNMapAnnotationSeismic else {
            return nil
        }
        
        let viewModel = SeismicNetworkViewModel(seismic: annotation.seismic)

        let annotationView = mapView.dequeueReusableAnnotationView(withIdentifier: EQNCustomAnnotationView.DoubleLineIdentifier, for: annotation) as! EQNCustomAnnotationView
        
        annotationView.image = annotation.image
        annotationView.title = annotation.title
        annotationView.subtitle = viewModel.magnitude
        
        return annotationView
    }
    
    func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer {
        guard let circleOverlay = overlay as? MKCircle else {
            return MKOverlayRenderer(overlay: overlay)
        }
        
        let circle = MKCircleRenderer(overlay: circleOverlay)
        circle.strokeColor = AppTheme.Colors.darkGray
        circle.lineWidth = 1.0
        return circle
    }
}

extension SeismicNetworksMapDetailViewController: SeismicFiltersViewControllerDelegate {
    func seismicFiltersControllerDidUpdateFilters(_ controller: SeismicFiltersViewController) {
        delegate?.seismicNetworksMapDetailControllerWillUpdateData(self, needsDataUpdate: controller.needsDataUpdate)
    }
}