require 'json'

module AddyLambda
  # Generic methods such as logging, error handling HTTP requests etc.
  class Common
    VARIABLE_DIRECT = 'direct'.freeze

    def self.generic_log(logger, event, context)
      logger.debug('## EVENT')
      logger.debug(event.inspect)
      logger.debug('## CONTEXT')
      logger.debug(context.inspect)
    end

    def self.get_body_as_object(event)
      body_as_object = {}

      if event.key?('body') and event['body'].is_a? String
        body_as_object = JSON.parse(event['body'])
      elsif event.key?('body')
        body_as_object = event['body']
      end

      body_as_object
    end

    def self.get_parameter(event, parameter, type, default_value = nil)
      event_body = get_body_as_object(event)

      case type
      when VARIABLE_DIRECT
        event_body.fetch(parameter, default_value)
      else
        default_value
      end
    end

    # sns = Aws::SNS::Resource.new(region: region)
    def self.handle_error(sns, logger, error, context)
      region = context.invoked_function_arn.split(':')[3]
      aws_account_id = context.invoked_function_arn.split(':')[4]

      err_msg = get_error_json(context, error)
      logger.error(err_msg)

      topic = sns.topic("arn:aws:sns:#{region}:#{aws_account_id}:system-errors")
      topic.publish(message: err_msg)
    end

    def self.handle_error_and_raise(sns, logger, error, context)
      handle_error(sns, logger, error, context)
      raise error
    end

    def self.get_error_json(context, error)
      {
        "function_name": context.function_name,
        "errorType": error.class,
        "errorMessage": error.message,
        "stackTrace": error.backtrace,
        "log_group_name": context.log_group_name,
        "log_stream_name": context.log_stream_name,
        "request id": context.aws_request_id
      }.to_json
    end

    def self.raise_error_description(description)
      raise StandardError, description
    end

    def self.enable_scout_apm
      return unless ENV['SCOUT_MONITOR'] == 'true'

      require 'scout_apm'
      ScoutApm::Agent.instance.install
    end

    def self.get_request(url, params = nil, headers = nil)
      uri = URI(url)
      uri.query = URI.encode_www_form(params) if params
      request = Net::HTTP::Get.new(uri.request_uri)
      http_request(request, uri, headers)
    end

    def self.delete_request(url, headers = nil)
      uri = URI(url)
      request = Net::HTTP::Delete.new(uri.request_uri)
      http_request(request, uri, headers)
    end

    def self.post_request(url, params = nil, headers = nil)
      uri = URI(url)
      request = Net::HTTP::Post.new(uri.request_uri)
      request.set_form_data(params) if params
      http_request(request, uri, headers)
    end

    def self.http_request(request, uri, headers)
      http = Net::HTTP.new(uri.host, uri.port)
      http.use_ssl = true
      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
      headers&.each { |header, value| request[header] = value }
      response = http.request(request)
      parse_response(response)
    end

    def self.parse_response(response)
      response_body = valid_json?(response.body) ? JSON.parse(response.body) : response.body
      return response_body if response.is_a?(Net::HTTPSuccess)

      raise_error_description(response_body['error_description'])
    rescue JSON::ParserError => e
      raise_error_description(e.message)
    end

    def self.logger
      @logger ||= Logger.new($stdout).tap { |logger| logger.level = ENV['LOG_LEVEL'].to_i }
    end

    def self.valid_json?(json)
      JSON.parse(json)
      true
    rescue JSON::ParserError
      false
    end
  end
end