defmodule ExAws.Lambda do
  @moduledoc """
  Operations on ExAws Lambda.
  """

  import ExAws.Utils, only: [camelize_key: 1, camelize_keys: 1, upcase: 1]
  require Logger

  @actions %{
    add_permission: :post,
    create_event_source_mapping: :post,
    create_function: :post,
    delete_event_source_mapping: :delete,
    delete_function: :delete,
    get_event_source_mapping: :get,
    get_function: :get,
    get_function_configuration: :get,
    get_policy: :get,
    invoke: :post,
    invoke_async: :post,
    list_event_source_mappings: :get,
    list_functions: :get,
    remove_permission: :delete,
    update_event_source_mapping: :put,
    update_function_code: :put,
    update_function_configuration: :put,
    tag_resource: :post
  }

  @type starting_position_vals :: :trim_horizon | :latest

  @type add_permission_opts :: [
          {:source_account, binary}
          | {:source_arn, binary}
        ]

  @doc """
  Adds a permission to the access policy associated with the specified AWS Lambda function.

  Action pattern: (lambda:[*]|lambda:[a-zA-Z]+|[*])
  """
  @spec add_permission(
          function_name :: binary,
          principal :: binary,
          action :: binary,
          statement_id :: binary
        ) :: ExAws.Operation.JSON.t()
  @spec add_permission(
          function_name :: binary,
          principal :: binary,
          action :: binary,
          statement_id :: binary,
          opts :: add_permission_opts
        ) :: ExAws.Operation.JSON.t()
  def add_permission(function_name, principal, action, statement_id, opts \\ []) do
    data =
      opts
      |> normalize_opts
      |> Map.merge(%{
        "Action" => action,
        "Principal" => principal,
        "StatementId" => statement_id
      })

    request(:add_permission, data, "/2015-03-31/functions/#{function_name}/versions/HEAD/policy")
  end

  @type create_event_source_mapping_opts :: [
          {:batch_size, pos_integer}
          | {:enabled, boolean}
        ]
  @doc """
  Creates a stream based event source for a function.
  """
  @spec create_event_source_mapping(
          function_name :: binary,
          event_source_arn :: binary,
          starting_position :: starting_position_vals
        ) :: ExAws.Operation.JSON.t()
  @spec create_event_source_mapping(
          function_name :: binary,
          event_source_arn :: binary,
          starting_position :: starting_position_vals,
          opts :: create_event_source_mapping_opts
        ) :: ExAws.Operation.JSON.t()
  def create_event_source_mapping(function_name, event_source_arn, starting_position, opts \\ []) do
    data =
      opts
      |> normalize_opts
      |> Map.merge(%{
        "FunctionName" => function_name,
        "EventSourceArn" => event_source_arn,
        "StartingPosition" => starting_position |> upcase
      })

    request(:create_event_source_mapping, data, "/2015-03-31/event-source-mappings/")
  end

  @type create_function_opts :: [
          {:description, binary}
          | {:memory_size, pos_integer}
          | {:timeout, pos_integer}
        ]
  @doc """
  Create a function.

  Runtime defaults to nodejs, as that is the only one available.
  """
  @spec create_function(
          function_name :: binary,
          handler :: binary,
          zipfile :: binary
        ) :: ExAws.Operation.JSON.t()
  @spec create_function(
          function_name :: binary,
          handler :: binary,
          zipfile :: binary,
          opts :: create_function_opts
        ) :: ExAws.Operation.JSON.t()
  def create_function(function_name, handler, zipfile, opts \\ []) do
    data =
      opts
      |> normalize_opts
      |> Map.merge(%{
        "FunctionName" => function_name,
        "Handler" => handler,
        "Code" => %{"ZipFile" => zipfile}
      })

    request(:create_function, data, "/2015-03-31/functions")
  end

  @doc """
  Delete an event source mapping.
  """
  @spec delete_event_source_mapping(source_mapping_uuid :: binary) :: ExAws.Operation.JSON.t()
  def delete_event_source_mapping(source_mapping_uuid) do
    request(
      :delete_event_source_mapping,
      %{},
      "/2015-03-31/event-source-mappings/#{source_mapping_uuid}"
    )
  end

  @doc """
  Delete a lambda function.
  """
  @spec delete_function(function_name :: binary) :: ExAws.Operation.JSON.t()
  def delete_function(function_name) do
    request(:delete_function, %{}, "/2015-03-31/functions/#{function_name}")
  end

  @doc """
  Get an event source mapping.
  """
  @spec get_event_source_mapping(source_mapping_uuid :: binary) :: ExAws.Operation.JSON.t()
  def get_event_source_mapping(source_mapping_uuid) do
    request(
      :get_event_source_mapping,
      %{},
      "/2015-03-31/event-source-mappings/#{source_mapping_uuid}"
    )
  end

  @doc """
  Get a function.
  """
  @spec get_function(function_name :: binary) :: ExAws.Operation.JSON.t()
  def get_function(function_name) do
    request(:get_function, %{}, "/2015-03-31/functions/#{function_name}/versions/HEAD")
  end

  @doc """
  Get a function configuration.
  """
  @spec get_function_configuration(function_name :: binary) :: ExAws.Operation.JSON.t()
  def get_function_configuration(function_name) do
    request(
      :get_function_configuration,
      %{},
      "/2015-03-31/functions/#{function_name}/versions/HEAD/configuration"
    )
  end

  @doc """
  Get a function access policy.
  """
  @spec get_policy(function_name :: binary) :: ExAws.Operation.JSON.t()
  def get_policy(function_name) do
    request(:get_policy, %{}, "/2015-03-31/functions/#{function_name}/versions/HEAD/policy")
  end

  @doc """
  Invoke a lambda function.
  """
  @type invoke_opts :: [
          {:invocation_type, :event | :request_response | :dry_run}
          | {:log_type, :none | :tail}
          | {:qualifier, String.t()}
        ]
  @spec invoke(function_name :: binary, payload :: map(), client_context :: map()) ::
          ExAws.Operation.JSON.t()
  @spec invoke(
          function_name :: binary,
          payload :: map(),
          client_context :: map(),
          opts :: invoke_opts
        ) :: ExAws.Operation.JSON.t()
  @context_header "X-Amz-Client-Context"
  def invoke(function_name, payload, client_context, opts \\ []) do
    {qualifier, opts} = Map.pop(Enum.into(opts, %{}), :qualifier)

    headers =
      [
        invocation_type: "X-Amz-Invocation-Type",
        log_type: "X-Amz-Log-Type",
        xray_trace_id: "X-Amzn-Trace-Id"
      ]
      |> Enum.reduce([], fn {opt, header}, headers ->
        case Map.fetch(opts, opt) do
          :error -> headers
          {:ok, nil} -> headers
          {:ok, value} -> [{header, value |> camelize_key} | headers]
        end
      end)

    headers =
      case client_context do
        %{} ->
          headers

        context ->
          [{@context_header, context} | headers]
      end

    url = "/2015-03-31/functions/#{function_name}/invocations"
    url = if qualifier, do: url <> "?Qualifier=#{qualifier}", else: url

    request(:invoke, payload, url, [], headers, fn operation, config ->
      headers =
        operation.headers
        |> List.keyfind(@context_header, 0, nil)
        |> case do
          nil ->
            operation.headers

          {_, val} ->
            new_val = val |> config.json_codec.encode! |> Base.encode64()
            List.keyreplace(operation.headers, @context_header, 0, {@context_header, new_val})
        end

      %{operation | headers: headers}
    end)
  end

  @doc """
  Invoke a lambda function asynchronously.
  """
  @spec invoke_async(function_name :: binary, args :: map()) :: ExAws.Operation.JSON.t()
  def invoke_async(function_name, args) do
    Logger.info(
      "This API is deprecated. See invoke/5 with the Event value set as invocation type"
    )

    request(
      :invoke,
      args |> normalize_opts,
      "/2014-11-13/functions/#{function_name}/invoke-async/"
    )
  end

  @doc """
  List event source mappings.
  """
  @type list_event_source_mappings_opts :: [
          {:event_source_arn, binary}
          | {:function_name, binary}
          | {:marker, binary}
          | {:max_items, pos_integer}
        ]
  @spec list_event_source_mappings() :: ExAws.Operation.JSON.t()
  @spec list_event_source_mappings(opts :: list_event_source_mappings_opts) ::
          ExAws.Operation.JSON.t()
  def list_event_source_mappings(opts \\ []) do
    params =
      opts
      |> normalize_opts

    request(:list_event_source_mappings, %{}, "/2015-03-31/event-source-mappings/", params)
  end

  @doc """
  List functions.
  """
  @type list_functions_opts :: [
          {:marker, binary}
          | {:max_items, pos_integer}
        ]
  @spec list_functions() :: ExAws.Operation.JSON.t()
  @spec list_functions(opts :: list_functions_opts) :: ExAws.Operation.JSON.t()
  def list_functions(opts \\ []) do
    request(:list_functions, %{}, "/2015-03-31/functions/", normalize_opts(opts))
  end

  @doc """
  Remove individual permissions from an function's access policy.
  """
  @spec remove_permission(function_name :: binary, statement_id :: binary) ::
          ExAws.Operation.JSON.t()
  def remove_permission(function_name, statement_id) do
    request(
      :remove_permission,
      %{},
      "/2015-03-31/functions/#{function_name}/versions/HEAD/policy/#{statement_id}"
    )
  end

  @doc """
  Update event source mapping.
  """
  @spec update_event_source_mapping(uuid :: binary, attrs_to_update :: map()) ::
          ExAws.Operation.JSON.t()
  def update_event_source_mapping(uuid, attrs_to_update) do
    request(
      :update_event_source_mapping,
      attrs_to_update,
      "/2015-03-31/event-source-mappings/#{uuid}"
    )
  end

  @doc """
  Update function code.
  """
  @spec update_function_code(function_name :: binary, zipfile :: binary) ::
          ExAws.Operation.JSON.t()
  def update_function_code(function_name, zipfile) do
    data = %{"ZipFile" => zipfile}

    request(
      :update_function_code,
      data,
      "/2015-03-31/functions/#{function_name}/versions/HEAD/code"
    )
  end

  @doc """
  Update a function configuration.
  """
  @spec update_function_configuration(function_name :: binary, configuration :: map()) ::
          ExAws.Operation.JSON.t()
  def update_function_configuration(function_name, configuration) do
    data = configuration |> normalize_opts

    request(
      :update_function_configuration,
      data,
      "/2015-03-31/functions/#{function_name}/configuration"
    )
  end

  @doc """
  Tag the Lambda resource.
  """
  @spec tag_resource(function_name :: binary, tags :: map()) :: ExAws.Operation.JSON.t()
  def tag_resource(function_arn, tags) do
    data = %{"Tags" => Map.new(tags, fn {k, v} -> {to_string(k), v} end)}

    request(
      :tag_resource,
      data,
      "/2017-03-31/tags/#{function_arn}"
    )
  end

  defp normalize_opts(opts) do
    opts
    |> Map.new()
    |> camelize_keys
  end

  defp request(action, data, path, params \\ [], headers \\ [], before_request \\ nil) do
    path = [path, "?", params |> URI.encode_query()] |> IO.iodata_to_binary()
    http_method = @actions |> Map.fetch!(action)

    ExAws.Operation.JSON.new(:lambda, %{
      http_method: http_method,
      path: path,
      data: data,
      headers: [{"content-type", "application/json"} | headers],
      before_request: before_request
    })
  end
end