# frozen_string_literal: true

class MapController < ApplicationController
  before_action :authenticate_user!

  def index
    @points = points.where('timestamp >= ? AND timestamp <= ?', start_at, end_at)

    @coordinates = []
      # @points.pluck(:lonlat, :battery, :altitude, :timestamp, :velocity, :id, :country)
      #        .map { |lonlat, *rest| [lonlat.y, lonlat.x, *rest.map(&:to_s)] }
    tracks_data = current_user.tracks
      .where('start_at <= ? AND end_at >= ?', Time.zone.at(end_at), Time.zone.at(start_at))
      .order(start_at: :asc)
      .pluck(:id, :start_at, :end_at, :distance, :avg_speed, :duration,
             :elevation_gain, :elevation_loss, :elevation_max, :elevation_min, :original_path)

    @tracks = tracks_data.map do |id, start_at, end_at, distance, avg_speed, duration,
                                elevation_gain, elevation_loss, elevation_max, elevation_min, original_path|
      {
        id: id,
        start_at: start_at.iso8601,
        end_at: end_at.iso8601,
        distance: distance&.to_f || 0,
        avg_speed: avg_speed&.to_f || 0,
        duration: duration || 0,
        elevation_gain: elevation_gain || 0,
        elevation_loss: elevation_loss || 0,
        elevation_max: elevation_max || 0,
        elevation_min: elevation_min || 0,
        original_path: original_path&.to_s
      }
    end
    @distance = distance
    @start_at = Time.zone.at(start_at)
    @end_at = Time.zone.at(end_at)
    @years = (@start_at.year..@end_at.year).to_a
    @points_number = @coordinates.count
  end

  private

  def start_at
    return Time.zone.parse(params[:start_at]).to_i if params[:start_at].present?
    return Time.zone.at(points.last.timestamp).beginning_of_day.to_i if points.any?

    Time.zone.today.beginning_of_day.to_i
  end

  def end_at
    return Time.zone.parse(params[:end_at]).to_i if params[:end_at].present?
    return Time.zone.at(points.last.timestamp).end_of_day.to_i if points.any?

    Time.zone.today.end_of_day.to_i
  end

  def distance
    @distance ||= 0

    @coordinates.each_cons(2) do
      @distance += Geocoder::Calculations.distance_between(
        [_1[0], _1[1]], [_2[0], _2[1]], units: current_user.safe_settings.distance_unit.to_sym
      )
    end

    @distance.round(1)
  end

  def points
    params[:import_id] ? points_from_import : points_from_user
  end

  def points_from_import
    current_user.imports.find(params[:import_id]).points.without_raw_data.order(timestamp: :asc)
  end

  def points_from_user
    current_user.tracked_points.without_raw_data.order(timestamp: :asc)
  end
end