defmodule ExAws.Timestream.Write do
  import ExAws.Utils, only: [camelize_keys: 2]
  @namespace "Timestream_20181101"

  @moduledoc """
  The following actions are supported by Amazon Timestream Write.
  https://docs.aws.amazon.com/timestream/latest/developerguide/API_Operations_Amazon_Timestream_Write.html
  """

  @type database_name :: binary
  @type table_name :: binary

  @type tag :: ExAws.Timestream.Write.Tag.t()
  @type tags :: list(tag)

  @type retention_properties :: %{
          magnetic_retention: pos_integer,
          memory_retention: pos_integer
        }

  @type resource_arn :: binary
  @type record :: %ExAws.Timestream.Write.Record{}

  @doc "DescribeEndpoints returns a list of available endpoints to make Timestream API calls against"
  @spec describe_endpoints() :: ExAws.Operation.JSON.t()
  def describe_endpoints do
    endpoint_operation()
  end

  ## Amazon Timestream Write : Database
  ######################

  @doc """
  Creates a new Timestream database.

  ## Options

    * `km_key_id` - The KMS key for the database.
    * `tags` - A list of tags to label the database.

  ## Examples - create_database/1

      ExAws.Timestream.Write.create_database("database_name")

  ## Examples - create_database/2

      tag = ExAws.Timestream.Write.Tag.new("tag_key", "tag_value")
      ExAws.Timestream.Write.create_database("database_name", km_key_id: 1, tags: [tag])
  """
  @type create_database_opts :: [
          {:km_key_id, pos_integer}
          | {:tags, tags}
        ]
  @spec create_database(database_name :: database_name) :: ExAws.Operation.EndpointDiscovery.t()
  @spec create_database(database_name :: database_name, opts :: create_database_opts) ::
          ExAws.Operation.JSON.t()
  def create_database(database_name, opts \\ []) do
    request(:create_database, %{
      "DatabaseName" => database_name,
      "KmsKeyId" => Keyword.get(opts, :km_key_id, nil),
      "Tags" => Keyword.get(opts, :tags, []) |> build_tags
    })
    |> dynamic_endpoint_request()
  end

  defp build_tags(tags) do
    tags
    |> Enum.map(fn %ExAws.Timestream.Write.Tag{key: key, value: value} ->
      %{
        "Key" => key,
        "Value" => value
      }
    end)
  end

  @doc "Deletes a given Timestream database."
  @spec delete_database(database_name :: database_name) :: ExAws.Operation.EndpointDiscovery.t()
  def delete_database(database_name) do
    request(:delete_database, %{"DatabaseName" => database_name})
    |> dynamic_endpoint_request()
  end

  @doc "Returns information about the database."
  @spec describe_database(database_name :: database_name) :: ExAws.Operation.EndpointDiscovery.t()
  def describe_database(database_name) do
    request(:describe_database, %{"DatabaseName" => database_name})
    |> dynamic_endpoint_request()
  end

  @doc "Returns a list of your Timestream databases."
  @type list_databases_opts :: [
          {:max_results, pos_integer}
          | {:next_token, binary}
        ]
  @spec list_databases() :: ExAws.Operation.EndpointDiscovery.t()
  @spec list_databases(list_databases_opts :: list_databases_opts) ::
          ExAws.Operation.EndpointDiscovery.t()
  def list_databases(opts \\ []) do
    request(:list_databases, %{
      "MaxResults" => Keyword.get(opts, :max_results, nil),
      "NextToken" => Keyword.get(opts, :next_token, nil)
    })
    |> dynamic_endpoint_request()
  end

  @doc "Modifies the KMS key for an existing database."
  @spec update_database(database_name :: database_name, km_key_id :: pos_integer) ::
          ExAws.Operation.JSON.t()
  def update_database(database_name, km_key_id) do
    request(:update_database, %{
      "DatabaseName" => database_name,
      "KmsKeyId" => km_key_id
    })
    |> dynamic_endpoint_request()
  end

  ## Amazon Timestream Write : Table
  ######################

  @doc """
  The CreateTable operation adds a new table to an existing database in your account.

  ## Options

    * `retention_properties` - The duration for which your time series data must be stored in the memory store and the magnetic store.
    * `tags` - A list of tags to label the database.

  ## Examples - create_table/2

      ExAws.Timestream.Write.create_table("database_name", "table_name")

  ## Examples - create_table/3

      tag = ExAws.Timestream.Write.Tag.new("tag_key", "tag_value")
      retention_properties = %{ magnetic_retention: 1, memory_retention: 1 }
      ExAws.Timestream.Write.create_table("database_name", "table_name",
        retention_properties: retention_properties, tags: [tag])
  """
  @type create_table_opts :: [
          {:tags, tags}
          | {:retention_properties, retention_properties}
        ]
  @spec create_table(database_name :: database_name, table_name :: table_name) ::
          ExAws.Operation.JSON.t()
  @spec create_table(
          database_name :: database_name,
          table_name :: table_name,
          create_table_opts :: create_table_opts
        ) :: ExAws.Operation.EndpointDiscovery.t()
  def create_table(database_name, table_name, opts \\ []) do
    request(:create_table, %{
      "DatabaseName" => database_name,
      "TableName" => table_name,
      "Tags" => Keyword.get(opts, :tags, []) |> build_tags,
      "RetentionProperties" =>
        Keyword.get(opts, :retention_properties, nil) |> build_retention_properties
    })
    |> dynamic_endpoint_request()
  end

  defp build_retention_properties(retention_properties) when is_nil(retention_properties), do: nil

  defp build_retention_properties(%{
         magnetic_retention: magnetic_retention,
         memory_retention: memory_retention
       }) do
    %{
      "MagneticStoreRetentionPeriodInDays" => magnetic_retention,
      "MemoryStoreRetentionPeriodInHours" => memory_retention
    }
  end

  @doc "Deletes a given Timestream table."
  @spec delete_table(database_name :: database_name, km_key_id :: table_name) ::
          ExAws.Operation.JSON.t()
  def delete_table(database_name, table_name) do
    request(:delete_table, %{
      "DatabaseName" => database_name,
      "TableName" => table_name
    })
    |> dynamic_endpoint_request()
  end

  @doc "Returns information about the table."
  @spec describe_table(database_name :: database_name, km_key_id :: table_name) ::
          ExAws.Operation.JSON.t()
  def describe_table(database_name, table_name) do
    request(:describe_table, %{
      "DatabaseName" => database_name,
      "TableName" => table_name
    })
    |> dynamic_endpoint_request()
  end

  @doc "Returns a list of your Timestream tables."
  @type list_tables_opts :: [
          {:database_name, database_name}
          | {:max_results, pos_integer}
          | {:next_token, binary}
        ]
  @spec list_tables() :: ExAws.Operation.EndpointDiscovery.t()
  @spec list_tables(list_tables_opts) :: ExAws.Operation.EndpointDiscovery.t()
  def list_tables(opts \\ []) do
    request(:list_tables, %{
      "DatabaseName" => Keyword.get(opts, :database_name, nil),
      "MaxResults" => Keyword.get(opts, :max_results, nil),
      "NextToken" => Keyword.get(opts, :next_token, nil)
    })
    |> dynamic_endpoint_request()
  end

  @doc "Modifies the retention duration of the memory store and magnetic store for your Timestream table."
  @spec update_table(
          database_name :: database_name,
          km_key_id :: table_name,
          retention_properties :: retention_properties
        ) :: ExAws.Operation.EndpointDiscovery.t()
  def update_table(database_name, table_name, retention_properties) do
    request(:update_table, %{
      "DatabaseName" => database_name,
      "TableName" => table_name,
      "RetentionProperties" => retention_properties |> build_retention_properties
    })
    |> dynamic_endpoint_request()
  end

  ## Amazon Timestream Write : TagResource
  ######################

  @doc "List all tags on a Timestream resource."
  @spec list_tags_for_resource(resource_arn :: resource_arn) ::
          ExAws.Operation.EndpointDiscovery.t()
  def list_tags_for_resource(resource_arn) do
    request(:list_tags_for_resource, %{
      "ResourceARN" => resource_arn
    })
    |> dynamic_endpoint_request()
  end

  @doc """
  Associate a set of tags with a Timestream resource.

  ## Examples
      tags = [
        ExAws.Timestream.Write.Tag.new("tag_key_1", "tag_value_1"),
        ExAws.Timestream.Write.Tag.new("tag_key_2", "tag_value_2")
      ]
      ExAws.Timestream.Write.tag_resource("resource_arn", tags)
  """
  @spec tag_resource(resource_arn :: resource_arn, tags :: tags) ::
          ExAws.Operation.EndpointDiscovery.t()
  def tag_resource(resource_arn, tags) do
    request(:tag_resource, %{
      "ResourceARN" => resource_arn,
      "Tags" => tags |> build_tags
    })
    |> dynamic_endpoint_request()
  end

  @doc "Removes the association of tags from a Timestream resource."
  @spec untag_resource(resource_arn :: resource_arn, tag_keys :: [binary]) ::
          ExAws.Operation.JSON.t()
  def untag_resource(resource_arn, tag_keys) do
    request(:untag_resource, %{
      "ResourceARN" => resource_arn,
      "TagKeys" => tag_keys
    })
    |> dynamic_endpoint_request()
  end

  ## Amazon Timestream Write : time series data
  ######################

  @doc "The WriteRecords operation enables you to write your time series data into Timestream."
  @type write_records_opts :: [
          {:common_attributes, record}
        ]
  @spec write_records(
          records :: [record],
          database_name :: database_name,
          table_name :: table_name
        ) :: ExAws.Operation.EndpointDiscovery.t()
  @spec write_records(
          records :: [record],
          database_name :: database_name,
          table_name :: table_name,
          write_records :: write_records_opts
        ) :: ExAws.Operation.EndpointDiscovery.t()
  def write_records(records, database_name, table_name, opts \\ []) do
    request(:write_records, %{
      "DatabaseName" => database_name,
      "TableName" => table_name,
      "Records" => Enum.map(records, &build_record/1),
      "CommonAttributes" => Keyword.get(opts, :common_attributes, nil) |> build_record
    })
    |> dynamic_endpoint_request()
  end

  defp build_record(record) when is_nil(record), do: nil

  defp build_record(record) do
    record
    |> Map.from_struct()
    |> Map.update!(:dimensions, fn current_dimensions ->
      current_dimensions
      |> Enum.map(fn dimension ->
        dimension
        |> Map.from_struct()
        |> camelize_keys(deep: false)
      end)
    end)
    |> Map.update!(:measure_values, fn current_measure_value ->
      if current_measure_value == nil or current_measure_value == [] do
        nil
      else
        current_measure_value
        |> Enum.map(fn measure_value ->
          measure_value
          |> Map.from_struct()
          |> camelize_keys(deep: false)
        end)
      end
    end)
    |> Enum.filter(fn {_k, v} -> not is_nil(v) end)
    |> Map.new()
    |> camelize_keys(deep: false)
  end

  defp request(op, data) do
    ExAws.Operation.JSON.new(
      :ingest_timestream,
      http_method: :post,
      data: data,
      headers: [
        {"x-amz-target", "#{@namespace}.#{format_operation_name(op)}"},
        {"content-type", "application/x-amz-json-1.0"}
      ]
    )
  end

  defp format_operation_name(operation) do
    operation
    |> Atom.to_string()
    |> Macro.camelize()
  end

  defp dynamic_endpoint_request(request_op, endpoint_op \\ endpoint_operation()) do
    ExAws.Operation.EndpointDiscovery.new(:ingest_timestream,
      request_operation: request_op,
      endpoint_operation: endpoint_op
    )
  end

  defp endpoint_operation() do
    request(:describe_endpoints, %{})
  end
end