require 'json'
require 'aws-sdk-lambda'

module AddyLambda
  # Generic methods such as logging, error handling HTTP requests etc.
  class Common
    def self.generic_log(logger, event, context)
      logger.debug('## EVENT')
      logger.debug(event.inspect)
      logger.debug('## CONTEXT')
      logger.debug(context.inspect)
    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

    # Lambda client can be obtained by running: lambda_client = Aws::Lambda::Client.new
    def self.post_slack_message(lambda_client, channel, message, emoji = ':tada', unfurl_links: false)
      input_params = {
        'user' => 'Signature Request',
        'channel' => channel,
        'message' => message,
        'emoji' => emoji,
        'unfurl_links' => unfurl_links
      }
      response_body = invoke_lambda(lambda_client, 'slack-client', input_params)
      return response_body unless response_body.key?('error')

      logger.error(response_body['error'])
    end

    def self.invoke_lambda(lambda_client, function_name, payload)
      resp = lambda_client.invoke({
                                    function_name: function_name,
                                    invocation_type: 'RequestResponse',
                                    payload: payload.to_json
                                  })
      valid_json?(resp.payload.string)
      response_obj = JSON.parse(resp.payload.string)
      valid_json?(resp.payload.string) ? JSON.parse(response_obj['body']) : resp.payload.string
    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)
      response = 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