# frozen_string_literal: true

module GPX
  class File
    require "libxml"

    include LibXML

    attr_reader :possible_points, :actual_points, :tracksegs

    def initialize(file, options = {})
      @file = file
      @maximum_points = options[:maximum_points] || Float::INFINITY
    end

    def parse_file(reader)
      point = nil

      while reader.read
        case reader.node_type
        when XML::Reader::TYPE_ELEMENT
          if reader.name == "trkpt"
            point = TrkPt.new(@tracksegs, reader["lat"].to_f, reader["lon"].to_f)
            @possible_points += 1
            raise FileTooBigError if @possible_points > @maximum_points
          elsif reader.name == "ele" && point
            point.altitude = reader.read_string.to_f
          elsif reader.name == "time" && point
            point.timestamp = Time.parse(reader.read_string).utc
          end
        when XML::Reader::TYPE_END_ELEMENT
          if reader.name == "trkpt" && point&.valid?
            point.altitude ||= 0
            yield point
            @actual_points += 1
            @lats << point.latitude
            @lons << point.longitude
          elsif reader.name == "trkseg"
            @tracksegs += 1
          end
        end
      end
    end

    def points(&block)
      return enum_for(:points) unless block

      @possible_points = 0
      @actual_points = 0
      @tracksegs = 0
      @lats = []
      @lons = []

      begin
        Archive::Reader.open_filename(@file).each_entry_with_data do |entry, data|
          parse_file(XML::Reader.string(data), &block) if entry.regular?
        end
      rescue Archive::Error
        io = ::File.open(@file)

        case Marcel::MimeType.for(io)
        when "application/gzip" then io = Zlib::GzipReader.open(@file)
        when "application/x-bzip2" then io = Bzip2::FFI::Reader.open(@file)
        end

        parse_file(XML::Reader.io(io, :options => XML::Parser::Options::NOERROR), &block)
      end
    end

    def picture(min_lat, min_lon, max_lat, max_lon, num_points)
      nframes = 10
      width = 250
      height = 250
      delay = 50

      points_per_frame = (num_points.to_f / nframes).ceil

      proj = OSM::Mercator.new(min_lat, min_lon, max_lat, max_lon, width, height)

      frames = []

      (0...nframes).each do |n|
        frames[n] = GD2::Image::IndexedColor.new(width, height)
        black = frames[n].palette.allocate(GD2::Color[0, 0, 0])
        white = frames[n].palette.allocate(GD2::Color[255, 255, 255])
        grey = frames[n].palette.allocate(GD2::Color[187, 187, 187])

        frames[n].draw do |pen|
          pen.color = white
          pen.rectangle(0, 0, width, height, true)
        end

        frames[n].draw do |pen|
          pen.color = black
          pen.anti_aliasing = true
          pen.dont_blend = false

          oldpx = 0.0
          oldpy = 0.0

          first = true

          @actual_points.times do |pt|
            px = proj.x @lons[pt]
            py = proj.y @lats[pt]

            if (pt >= (points_per_frame * n)) && (pt <= (points_per_frame * (n + 1)))
              pen.thickness = 3
              pen.color = black
            else
              pen.thickness = 1
              pen.color = grey
            end

            pen.line(px, py, oldpx, oldpy) unless first
            first = false
            oldpy = py
            oldpx = px
          end
        end
      end

      image = GD2::AnimatedGif.new
      image.add(frames.first)
      frames.each do |frame|
        image.add(frame, :delay => delay)
      end
      image.end

      output = StringIO.new
      image.export(output)
      output
    end

    def icon(min_lat, min_lon, max_lat, max_lon)
      width = 50
      height = 50
      proj = OSM::Mercator.new(min_lat, min_lon, max_lat, max_lon, width, height)

      image = GD2::Image::IndexedColor.new(width, height)

      black = image.palette.allocate(GD2::Color[0, 0, 0])
      white = image.palette.allocate(GD2::Color[255, 255, 255])

      image.draw do |pen|
        pen.color = white
        pen.rectangle(0, 0, width, height, true)
      end

      image.draw do |pen|
        pen.color = black
        pen.anti_aliasing = true
        pen.dont_blend = false

        oldpx = 0.0
        oldpy = 0.0

        first = true

        @actual_points.times do |pt|
          px = proj.x @lons[pt]
          py = proj.y @lats[pt]

          pen.line(px, py, oldpx, oldpy) unless first

          first = false
          oldpy = py
          oldpx = px
        end
      end

      StringIO.new(image.gif)
    end
  end

  TrkPt = Struct.new(:segment, :latitude, :longitude, :altitude, :timestamp) do
    def valid?
      latitude && longitude && timestamp &&
        latitude >= -90 && latitude <= 90 &&
        longitude >= -180 && longitude <= 180
    end
  end

  class FileTooBigError < RuntimeError
    def initialise
      super("GPX File contains too many points")
    end
  end
end
