keen_auth

defmodule KeenAuth.Storage do
  @moduledoc """
  Defines the storage behavior for persisting authentication data.



  Storage is the final stage in KeenAuth's pipeline architecture. It handles

  persisting user data, tokens, and session information. Storage implementations

  can be as simple as session-based or as sophisticated as multi-layer persistence.



  ## Pipeline Stage



  The storage is the final stage in the authentication flow:



  ```

  Strategy → Mapper → Processor → **Storage**

  ```



  ## Flexibility



  Storage implementations can vary based on your needs:



  - **Session Storage** (default): Simple session-based storage

  - **Database Storage**: Persistent user sessions in database

  - **JWT Storage**: Stateless authentication with JWT tokens

  - **Multi-layer**: Combine database + session + JWT for different purposes



  ## Example Implementation



      defmodule MyApp.Auth.DatabaseStorage do

        @behaviour KeenAuth.Storage



        def store(conn, provider, user, oauth_response) do

          {:ok, session} = create_user_session(user, provider)

          conn = put_session(conn, :session_id, session.id)

          {:ok, conn}

        end



        def current_user(conn) do

          with session_id when not is_nil(session_id) <- get_session(conn, :session_id),

               session when not is_nil(session) <- get_session_from_db(session_id) do

            session.user

          else

            _ -> nil

          end

        end



        # ... implement other callbacks

      end



  ## Configuration



  Configure a custom storage implementation:



      config :keen_auth,

        storage: MyApp.Auth.CustomStorage

  """

  alias KeenAuth.AuthenticationController
  alias KeenAuth.Config

  @default_storage KeenAuth.Storage.Session

  @callback store(
              conn :: Plug.Conn.t(),
              provider :: atom(),
              mapped_user :: KeenAuth.User.t() | map(),
              oauth_response :: AuthenticationController.oauth_callback_response() | nil
            ) :: {:ok, Plug.Conn.t()}
  @callback current_user(conn :: Plug.Conn.t()) :: any() | nil
  @callback authenticated?(conn :: Plug.Conn.t()) :: boolean()
  @callback get_access_token(conn :: Plug.Conn.t()) :: binary() | nil
  @callback get_id_token(conn :: Plug.Conn.t()) :: binary() | nil
  @callback get_refresh_token(conn :: Plug.Conn.t()) :: binary() | nil
  @callback get_provider(conn :: Plug.Conn.t()) :: binary() | nil
  @callback delete(conn :: Plug.Conn.t()) :: Plug.Conn.t()
  @callback put_provider(conn :: Plug.Conn.t(), provider :: atom()) :: Plug.Conn.t()
  @callback put_tokens(conn :: Plug.Conn.t(), provider :: atom(), AuthenticationController.tokens_map()) :: Plug.Conn.t()
  @callback put_current_user(conn :: Plug.Conn.t(), provider :: atom(), KeenAuth.User.t() | map()) :: Plug.Conn.t()

  defmacro __using__(_params \\ nil) do
    quote do
      @behaviour unquote(__MODULE__)

      def process(conn, provider, mapped_user, oauth_response), do: unquote(__MODULE__).process(conn, provider, mapped_user, oauth_response)
      def store(conn, provider, mapped_user, oauth_response), do: unquote(__MODULE__).store(conn, provider, mapped_user, oauth_response)
      def current_user(conn), do: unquote(__MODULE__).current_user(conn)
      def authenticated?(conn), do: unquote(__MODULE__).authenticated?(conn)
      def authenticated?(conn), do: unquote(__MODULE__).authenticated?(conn)
      def get_access_token(conn), do: unquote(__MODULE__).get_access_token(conn)
      def get_id_token(conn), do: unquote(__MODULE__).get_id_token(conn)
      def get_refresh_token(conn), do: unquote(__MODULE__).get_refresh_token(conn)
      def get_provider(conn), do: unquote(__MODULE__).get_provider(conn)
      def delete(conn), do: unquote(__MODULE__).delete(conn)
      def put_provider(conn, provider), do: unquote(__MODULE__).put_provider(conn, provider)
      def put_tokens(conn, provider, tokens), do: unquote(__MODULE__).put_tokens(conn, provider, tokens)
      def put_current_user(conn, provider, user), do: unquote(__MODULE__).put_current_user(conn, provider, user)

      defoverridable unquote(__MODULE__)
    end
  end

  def store(conn, provider, mapped_user, oauth_response) do
    current_storage(conn).store(conn, provider, mapped_user, oauth_response)
  end

  def current_user(conn) do
    current_storage(conn).current_user(conn)
  end

  def authenticated?(conn) do
    current_storage(conn).authenticated?(conn)
  end

  def get_access_token(conn) do
    current_storage(conn).get_access_token(conn)
  end

  def get_id_token(conn) do
    current_storage(conn).get_id_token(conn)
  end

  def get_refresh_token(conn) do
    current_storage(conn).get_refresh_token(conn)
  end

  def get_provider(conn) do
    current_storage(conn).get_provider(conn)
  end

  def delete(conn) do
    current_storage(conn).delete(conn)
  end

  def put_provider(conn, provider) do
    current_storage(conn).put_provider(conn, provider)
  end

  def put_tokens(conn, provider, tokens) do
    current_storage(conn).put_tokens(conn, provider, tokens)
  end

  def put_current_user(conn, provider, user) do
    current_storage(conn).put_current_user(conn, provider, user)
  end

  def current_storage(conn) do
    KeenAuth.Plug.fetch_config(conn)
    |> get_storage()
  end

  def get_storage(config) do
    Config.get(config, :storage, @default_storage)
  end
end