module DomoscioRails

# File lib/domoscio_rails.rb, line 81
def self.api_uri(url = '')
  URI(configuration.root_url + url)
end

# File lib/domoscio_rails.rb, line 76
def self.configure
  self.configuration ||= Configuration.new
  yield configuration
end

# File lib/domoscio_rails.rb, line 180
def self.perform_call(uri, method, params, headers)
  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
    req = Net::HTTP.const_get(method.capitalize).new(uri.request_uri, headers)
    req.body = DomoscioRails::JSON.dump(params)
    http.request req
  end
end

# File lib/domoscio_rails.rb, line 167
def self.raise_http_failure(uri, response, params)
  return if response.is_a?(Net::HTTPSuccess) || response.is_a?(Net::HTTPNoContent)

  raise ResponseError.new(
    uri,
    response.code.to_i,
    DomoscioRails::JSON.load((response.body.nil? ? '' : response.body), symbolize_keys: true),
    response.body, params
  )
end

# File lib/domoscio_rails.rb, line 96
def self.request(method, url, params = {})
  params ||= {}
  store_tokens, headers = request_headers
  params.merge!({ 'per_page': 1000 }) unless params[:per_page] || params["per_page"]
  uri = api_uri(url)
  response = DomoscioRails.send_request(uri, method, params, headers)
  return response if response.is_a? DomoscioRails::ProcessingError

  begin
    raise_http_failure(uri, response, params)

    if response['Content-Type'] == 'application/zip' || response['Content-Type'] == 'application/xlsx'
      data = response
    elsif response.is_a?(Net::HTTPNoContent)
      data = []
    else
      data = DomoscioRails::JSON.load(response.body.nil? ? '' : response.body)
    end

    if store_tokens
      DomoscioRails::AuthorizationToken::Manager.storage.store({
                                                                 access_token: response['Accesstoken'],
                                                                 refresh_token: response['Refreshtoken']
                                                               })
    end
  rescue MultiJson::LoadError => e
    data = ProcessingError.new(uri, 500, e, response.body, params)
  rescue ResponseError => e
    data = e
  end

  if response['Total'] || (response['Total-Pages'] && response['Total-Pages'] != '1')

    pagetotal = if response['Total']
                  (response['Total'].to_i / response['Per-Page'].to_f).ceil
                else
                  response['Total-Pages'].to_i
                end

    (2..pagetotal).each do |j|
      response = DomoscioRails.send_request(uri, method, params.merge({ page: j }), headers)
      return response if response.is_a? DomoscioRails::ProcessingError

      begin
        raise_http_failure(uri, response, params)
        body = DomoscioRails::JSON.load(response.body.nil? ? '' : response.body)
        data += body
        data.flatten!
      rescue MultiJson::LoadError => e
        return ProcessingError.new(uri, 500, e, response.body, params)
      rescue ResponseError => e
        return e
      end
    end
  end
  data
end

# File lib/domoscio_rails.rb, line 220
def self.request_headers
  auth_token = DomoscioRails::AuthorizationToken::Manager.token
  if auth_token && auth_token[:access_token] && auth_token[:refresh_token]
    [false, send_current_tokens(auth_token)]
  else
    [true, request_new_tokens]
  end
rescue SyntaxError, StandardError
  [true, request_new_tokens]
end

# File lib/domoscio_rails.rb, line 245
def self.request_new_tokens
  {
    'user_agent' => DomoscioRails.user_agent.to_s,
    'Authorization' => "Token token=#{DomoscioRails.configuration.client_passphrase}",
    'Content-Type' => 'application/json'
  }
end

# File lib/domoscio_rails.rb, line 190
def self.retry_call_and_store_tokens(uri, method, params)
  headers = request_new_tokens
  response = perform_call(uri, method, params, headers)
  DomoscioRails::AuthorizationToken::Manager.storage.store({
                                                             access_token: response['Accesstoken'],
                                                             refresh_token: response['Refreshtoken']
                                                           })
  response
end

# File lib/domoscio_rails.rb, line 233
def self.send_current_tokens(auth_token)
  headers = {
    'user_agent' => DomoscioRails.user_agent.to_s,
    'AccessToken' => auth_token[:access_token].to_s,
    'RefreshToken' => auth_token[:refresh_token].to_s,
    'Content-Type' => 'application/json'
  }
  headers.merge!({ 'X-Auth-Type' => DomoscioRails.configuration.auth_type }) if DomoscioRails.configuration.auth_type
  headers
end

# File lib/domoscio_rails.rb, line 156
def self.send_request(uri, method, params, headers)
  response = perform_call(uri, method, params, headers)
  response = retry_call_and_store_tokens(uri, method, params) if %w[401 403].include? response.code && DomoscioRails.configuration.auth_type != 'user'
  response
rescue Timeout::Error, Errno::EINVAL, Errno::ECONNREFUSED, Errno::ECONNRESET,
       EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
  ProcessingError.new(uri, 500, e, response)
end

# File lib/domoscio_rails.rb, line 211
def self.uname
  `uname -a 2>/dev/null` if RUBY_PLATFORM =~ /linux|darwin/i
rescue Errno::ENOMEM
  'uname lookup failed'
end

# File lib/domoscio_rails.rb, line 200
def self.user_agent
  @uname ||= uname
  {
    bindings_version: DomoscioRails::VERSION,
    lang: 'ruby',
    lang_version: "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})",
    platform: RUBY_PLATFORM,
    uname: @uname
  }.to_s
end