module Ratis

  class NextBus

    attr_accessor :stop, :services, :success

    def initialize(response)
      @success  = response.success?
      @stop     = response.body[:nextbus_response][:atstop]
      _services = @stop.delete(:service)

      unless _services.is_a?(Array)
        _services = [_services]
      end

      @services = _services.map do |service|
        OpenStruct.new(:status      => service[:status],
                       :sign        => service[:sign],
                       :routetype   => service[:routetype],
                       :times       => service[:times],
                       :direction   => service[:direction],
                       :servicetype => service[:servicetype],
                       :route       => service[:route],
                       :operator    => service[:operator],
                       :trips       => service[:tripinfo].map do |ti|
                                         OpenStruct.new(:triptime   => ti[:triptime],
                                                        :block      => ti[:block],
                                                        :tripid     => ti[:tripid],
                                                        :exception  => ti[:exception],
                                                        :skedtripid => ti[:skedtripid],
                                                        :realtime   => OpenStruct.new(:valid            => ti[:realtime][:valid],
                                                                                      :adherence        => ti[:realtime][:adherence],
                                                                                      :estimatedtime    => ti[:realtime][:estimatedtime],
                                                                                      :estimatedminutes => ti[:realtime][:estimatedminutes],
                                                                                      :polltime         => ti[:realtime][:polltime],
                                                                                      :trend            => ti[:realtime][:trend],
                                                                                      :speed            => ti[:realtime][:speed],
                                                                                      :reliable         => ti[:realtime][:reliable],
                                                                                      :stopped          => ti[:realtime][:stopped],
                                                                                      :lat              => ti[:realtime][:lat],
                                                                                      :long             => ti[:realtime][:long] ))
                                       end
                       )
      end

    end

    def self.where(conditions)
      stop_id = conditions.delete(:stop_id)
      app_id  = conditions.delete(:app_id) || 'ratis-gem'
      type    = conditions.delete(:type) || 'N' # N for Next Bus

      if datetime = conditions.delete(:datetime)
        raise ArgumentError.new('If datetime supplied it should be a Time or DateTime instance, otherwise it defaults to Time.now') unless datetime.is_a?(DateTime) || datetime.is_a?(Time)
      else
        datetime = Time.now
      end

      raise ArgumentError.new('You must provide a stop ID') unless stop_id

      Ratis.all_conditions_used?(conditions)

      response = Request.get 'Nextbus', {'Stopid' => stop_id,
                                         'Appid' => app_id,
                                         'Date' => datetime.strftime("%m/%d/%Y"),
                                         'Time' => datetime.strftime("%I%M"),
                                         'Type' => type }

      NextBus.new(response)
    end

    def success?
      @success
    end

    # Gets description of first stop
    # @return [String] Description of first stop or nil.

    def first_stop_description
      raise 'Not yet implemented'
      stops.first ? stops.first[:description] : nil
    end

    # Details of NextBus instance in a hash.
    # @return     [Hash] NextBus details in a hash.

    def to_hash
      raise 'Not yet implemented'
      { :stopname => first_stop_description,
        :signs    => runs.map { |run| run[:sign] }.uniq,
        :runs     => runs.map do |run|
          { :time      => run[:estimatedtime],
            :sign      => run[:sign],
            :adherence => run[:adherence],
            :route     => run[:route]
          }
        end
      }
    end

    # Details of NextBus instance in a hash to be transformed to xml
    # @private

    def to_hash_for_xml
      raise 'Not yet implemented'
      { :stopname => first_stop_description,
        :runs     => runs.map do |run|
          { :time           => run[:estimatedtime],
            :scheduled_time => run[:triptime],
            :sign           => run[:sign],
            :adherence      => run[:adherence],
            :route          => run[:route]
          }
        end
      }
    end
  end

end