# encoding: utf-8

module OneApm
  module Support
    class Marshaller

      # Used to wrap errors reported to agent by the collector
      class CollectorError < StandardError; end

      def parsed_error(error)
        error_type    = error['error_type']
        error_message = error['message']

        exception = case error_type
        when 'OneApm::LicenseException'
          OneApm::LicenseException.new(error_message)
        when 'OneApm::ForceRestartException'
          OneApm::ForceRestartException.new(error_message)
        when 'OneApm::ForceDisconnectException'
          OneApm::ForceDisconnectException.new(error_message)
        else
          OneApm::Support::Marshaller::CollectorError.new("#{error['error_type']}: #{error['message']}")
        end

        exception
      end

      def prepare(data, options={})
        encoder = options[:encoder] || default_encoder
        if data.respond_to?(:to_collector_array)
          data.to_collector_array(encoder)
        elsif data.kind_of?(Array)
          data.map { |element| prepare(element, options) }
        else
          data
        end
      end

      def default_encoder
        Encoders::Identity
      end

      def self.human_readable?
        false
      end

      protected

      def return_value(data)
        if data.respond_to?(:has_key?)
          if data.has_key?('exception')
            raise parsed_error(data['exception'])
          elsif data.has_key?('return_value')
            return data['return_value']
          end
        end
        ::OneApm::Agent.logger.debug("Unexpected response from collector: #{data}")
        nil
      end
    end
  end
end