Repo created

iphone/Maps/UI/PlacePage/Components/ElevationProfile/ElevationProfilePresenter.swift

@@ -0,0 +1,191 @@
+import Chart
+import CoreApi
+
+protocol TrackActivePointPresenter: AnyObject {
+  func updateActivePointDistance(_ distance: Double)
+  func updateMyPositionDistance(_ distance: Double)
+}
+
+protocol ElevationProfilePresenterProtocol: UICollectionViewDataSource, UICollectionViewDelegateFlowLayout, TrackActivePointPresenter {
+  func configure()
+  func update(with trackData: PlacePageTrackData)
+  func onDifficultyButtonPressed()
+  func onSelectedPointChanged(_ point: CGFloat)
+}
+
+protocol ElevationProfileViewControllerDelegate: AnyObject {
+  func openDifficultyPopup()
+  func updateMapPoint(_ point: CLLocationCoordinate2D, distance: Double)
+}
+
+fileprivate struct DescriptionsViewModel {
+  let title: String
+  let value: String
+  let imageName: String
+}
+
+final class ElevationProfilePresenter: NSObject {
+  private weak var view: ElevationProfileViewProtocol?
+  private weak var trackData: PlacePageTrackData?
+  private weak var delegate: ElevationProfileViewControllerDelegate?
+  private let bookmarkManager: BookmarksManager = .shared()
+
+  private let cellSpacing: CGFloat = 8
+  private var descriptionModels: [DescriptionsViewModel]
+  private var chartData: ElevationProfileChartData?
+  private let formatter: ElevationProfileFormatter
+
+  init(view: ElevationProfileViewProtocol,
+       trackData: PlacePageTrackData,
+       formatter: ElevationProfileFormatter = ElevationProfileFormatter(),
+       delegate: ElevationProfileViewControllerDelegate?) {
+    self.view = view
+    self.delegate = delegate
+    self.formatter = formatter
+    self.trackData = trackData
+    if let profileData = trackData.elevationProfileData {
+      self.chartData = ElevationProfileChartData(profileData)
+    }
+    self.descriptionModels = Self.descriptionModels(for: trackData.trackInfo)
+  }
+
+  private static func descriptionModels(for trackInfo: TrackInfo) -> [DescriptionsViewModel] {
+    [
+      DescriptionsViewModel(title: L("elevation_profile_ascent"), value: trackInfo.ascent, imageName: "ic_em_ascent_24"),
+      DescriptionsViewModel(title: L("elevation_profile_descent"), value: trackInfo.descent, imageName: "ic_em_descent_24"),
+      DescriptionsViewModel(title: L("elevation_profile_max_elevation"), value: trackInfo.maxElevation, imageName: "ic_em_max_attitude_24"),
+      DescriptionsViewModel(title: L("elevation_profile_min_elevation"), value: trackInfo.minElevation, imageName: "ic_em_min_attitude_24")
+    ]
+  }
+}
+
+extension ElevationProfilePresenter: ElevationProfilePresenterProtocol {
+  func update(with trackData: PlacePageTrackData) {
+    self.trackData = trackData
+    if let profileData = trackData.elevationProfileData {
+      self.chartData = ElevationProfileChartData(profileData)
+    } else {
+      self.chartData = nil
+    }
+    descriptionModels = Self.descriptionModels(for: trackData.trackInfo)
+    configure()
+  }
+
+  func updateActivePointDistance(_ distance: Double) {
+    guard let view, view.canReceiveUpdates else { return }
+    view.setActivePointDistance(distance)
+  }
+
+  func updateMyPositionDistance(_ distance: Double) {
+    guard let view, view.canReceiveUpdates else { return }
+    view.setMyPositionDistance(distance)
+  }
+
+  func configure() {
+    view?.isChartViewHidden = false
+
+    let kMinPointsToDraw = 2
+    guard let trackData = trackData,
+          let profileData = trackData.elevationProfileData,
+          let chartData,
+          chartData.points.count >= kMinPointsToDraw else {
+      view?.userInteractionEnabled = false
+      return
+    }
+
+    view?.setChartData(ChartPresentationData(chartData, formatter: formatter))
+    view?.reloadDescription()
+
+    guard !profileData.isTrackRecording else {
+      view?.isChartViewInfoHidden = true
+      return
+    }
+
+    view?.userInteractionEnabled = true
+    view?.setActivePointDistance(trackData.activePointDistance)
+    view?.setMyPositionDistance(trackData.myPositionDistance)
+  }
+
+  func onDifficultyButtonPressed() {
+    delegate?.openDifficultyPopup()
+  }
+
+  func onSelectedPointChanged(_ point: CGFloat) {
+    guard let chartData else { return }
+    let distance: Double = floor(point) / CGFloat(chartData.points.count) * chartData.maxDistance
+    let point = chartData.points.first { $0.distance >= distance } ?? chartData.points[0]
+    delegate?.updateMapPoint(point.coordinates, distance: point.distance)
+  }
+}
+
+// MARK: - UICollectionDataSource
+
+extension ElevationProfilePresenter {
+  func collectionView(_ collectionView: UICollectionView, numberOfItemsInSection section: Int) -> Int {
+    return descriptionModels.count
+  }
+
+  func collectionView(_ collectionView: UICollectionView, cellForItemAt indexPath: IndexPath) -> UICollectionViewCell {
+    let cell = collectionView.dequeueReusableCell(cell: ElevationProfileDescriptionCell.self, indexPath: indexPath)
+    let model = descriptionModels[indexPath.row]
+    cell.configure(subtitle: model.title, value: model.value, imageName: model.imageName)
+    return cell
+  }
+}
+
+// MARK: - UICollectionViewDelegateFlowLayout
+
+extension ElevationProfilePresenter {
+  func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, sizeForItemAt indexPath: IndexPath) -> CGSize {
+    let width = collectionView.width
+    let cellHeight = collectionView.height
+    let modelsCount = CGFloat(descriptionModels.count)
+    let cellWidth = (width - cellSpacing * (modelsCount - 1) - collectionView.contentInset.right - collectionView.contentInset.left) / modelsCount
+    return CGSize(width: cellWidth, height: cellHeight)
+  }
+
+  func collectionView(_ collectionView: UICollectionView, layout collectionViewLayout: UICollectionViewLayout, minimumInteritemSpacingForSectionAt section: Int) -> CGFloat {
+    return cellSpacing
+  }
+}
+
+fileprivate struct ElevationProfileChartData {
+
+  struct Line: ChartLine {
+    var values: [ChartValue]
+    var color: UIColor
+    var type: ChartLineType
+  }
+
+  fileprivate let chartValues: [ChartValue]
+  fileprivate let chartLines: [Line]
+  fileprivate let distances: [Double]
+  fileprivate let maxDistance: Double
+  fileprivate let points: [ElevationHeightPoint]
+
+  init(_ elevationData: ElevationProfileData) {
+    self.points = elevationData.points
+    self.chartValues = points.map { ChartValue(xValues: $0.distance, y: $0.altitude) }
+    self.distances = points.map { $0.distance }
+    self.maxDistance = distances.last ?? 0
+    let lineColor = StyleManager.shared.theme?.colors.chartLine ?? .blue
+    let lineShadowColor = StyleManager.shared.theme?.colors.chartShadow ?? .lightGray
+    let l1 = Line(values: chartValues, color: lineColor, type: .line)
+    let l2 = Line(values: chartValues, color: lineShadowColor, type: .lineArea)
+    chartLines = [l1, l2]
+  }
+
+  private static func altBetweenPoints(_ p1: ElevationHeightPoint,
+                                       _ p2: ElevationHeightPoint,
+                                       at distance: Double) -> Double {
+    assert(distance > p1.distance && distance < p2.distance, "distance must be between points")
+    let d = (distance - p1.distance) / (p2.distance - p1.distance)
+    return p1.altitude + round(Double(p2.altitude - p1.altitude) * d)
+  }
+}
+
+extension ElevationProfileChartData: ChartData {
+  public var xAxisValues: [Double] { distances }
+  public var lines: [ChartLine] { chartLines }
+  public var type: ChartType { .regular }
+}