defmodule Needle.UID do
  @moduledoc "./README.md" |> File.stream!() |> Enum.drop(1) |> Enum.join()
  use Ecto.ParameterizedType
  import Untangle, except: [dump: 3]

  @pride_enabled Code.ensure_loaded?(Pride) and Application.compile_env(:needle_uid, :pride_enabled, false)
  @ulid_enabled Application.compile_env(:needle_uid, :ulid_enabled, true)

  @doc "translates alphanumerics into a sentinel ID value"
  def synthesise!(x) when is_binary(x) do
    # TODO with UUID
    Needle.ULID.synthesise!(x)
  end

  @doc """
  The underlying schema type.
  """
  @impl true
  def type(_params), do: :uuid

  @impl true
  def init(opts) do
    if @pride_enabled do
      if Keyword.get(opts, :prefix) do
        IO.warn("use prefixed UUIDv7 for #{inspect(opts)}")
        Pride.init(opts)
      else
        IO.warn("fallback to ULID for #{inspect(opts)}")
        Pride.init(opts ++ [allow_unprefixed: true])
      end
    else
      Map.new(opts)
    end
  end

  @impl true
  def equal?(a, b, params \\ nil)

  if @pride_enabled do
    def equal?(a, b, %{prefix: _} = params), do: Pride.equal?(a, b, params)
  end

  if @ulid_enabled do
    def equal?(a, b, _), do: Needle.ULID.equal?(a, b)
  end

  @impl true
  def embed_as(format, params \\ nil)

  if @pride_enabled do
    def embed_as(format, %{prefix: _} = params), do: Pride.embed_as(format, params)
  end

  if @ulid_enabled do
    def embed_as(format, _), do: Needle.ULID.embed_as(format)
  end

  @impl true
  def autogenerate(params), do: generate(params)
  def generate(params_or_timestamp \\ nil)

  if @pride_enabled do
    def generate(%{prefix: _} = params), do: Pride.autogenerate(params)
  end

  if @ulid_enabled do
    def generate(timestamp) when is_integer(timestamp), do: Needle.ULID.generate(timestamp)
    # def generate(%Date{} =timestamp), do: Needle.ULID.generate(timestamp) # TODO
    def generate(%DateTime{} =timestamp), do: Needle.ULID.generate(timestamp)
  end

  if @pride_enabled do
    def generate(schema) when is_atom(schema) and not is_nil(schema) do
      debug(schema, "gen schema")

      if function_exported?(schema, :__schema__, 1) do
        # hopefully ok to just take the first?
        case schema.__schema__(:primary_key) |> List.first() |> debug("gen primary_key first") do
          nil ->
            if @ulid_enabled do
              Needle.ULID.generate()
            end

          field ->
            generate(schema, field)
        end
      else
        if @ulid_enabled do
          Needle.ULID.generate()
        end
      end
    end
  end

  if @ulid_enabled do
    def generate(_), do: Needle.ULID.generate()
  end

  if @pride_enabled do
    def generate(schema, field) when is_atom(schema) do
      case Pride.params(schema, field) |> debug("gen prefix") do
        %{prefix: _} = params ->
          Pride.autogenerate(params)

        _ ->
          if @ulid_enabled do
            Needle.ULID.generate()
          end
      end
    end
  end

  @doc "Returns the timestamp of an encoded or unencoded UID"
  if @ulid_enabled do
    def timestamp(<<_::bytes-size(26)>> = encoded) do
      Needle.ULID.timestamp(encoded)
    end
  end

  def timestamp(encoded) do
    debug(encoded, "TODO")
    raise "#TODO for UUID"
  end

  @doc """
  Casts an encoded string to ID. Transforms outside data into runtime data.

  Used to (potentially) convert your data into an internal normalized representation which will be part of your changesets. It also used for verifying that something is actually valid input data for your type.
  """
  @impl true
  def cast(term, params \\ nil)
  def cast(nil, _params), do: {:ok, nil}

  if @pride_enabled do
    def cast(term, %{prefix: _} = params) do
      with {:error, _} <- Pride.cast(term, params) do
        # for old ULIDs in a prefixed table
        if @ulid_enabled and Needle.ULID.valid?(term) do
          {:ok, term}
        else
          {:error, message: "Not recognised as valid Prefixed UUIDv7 or ULID"}
        end
      end
    end
  end

  def cast(<<_::bytes-size(16)>> = value, _), do: {:ok, value}

  def cast(<<_::bytes-size(26)>> = value, params) do
    if @ulid_enabled and Needle.ULID.valid?(value) do
      {:ok, value}
    else
      if @pride_enabled do
        Pride.cast(value, params)
      else
        {:error, message: "Invalid ULID"}
      end
    end
  end

  if @pride_enabled do
    def cast(term, %{} = params), do: Pride.cast(term, params)
  end

  def cast(value, params) do
    debug(value, "Could not recognise value (with params: #{inspect(params)}) ")
    {:error, message: "Not recognised as valid ULID or Prefixed UUIDv7"}
  end

  @doc """
  Same as `cast/1` but raises `Ecto.CastError` on invalid arguments.
  """
  def cast!(value, params \\ nil) do
    case cast(value, params) do
      {:ok, uid} ->
        uid

      {:error, term} ->
        raise Ecto.CastError, type: __MODULE__, value: value, message: term[:message]

      :error ->
        raise Ecto.CastError, type: __MODULE__, value: value
    end
  end

  @doc """
  Converts an encoded ID into a binary. Used to get your data ready to be written to the database. Transforms anything (outside data or runtime data) into database column data
  """
  @impl true
  def dump(value, dumper \\ nil, params \\ nil)
  def dump(nil, _, _), do: {:ok, nil}

  if @pride_enabled do
    def dump(value, dumper, %{prefix: _} = params), do: Pride.dump(value, dumper, params)
  end

  if @ulid_enabled do
    def dump(<<_::bytes-size(26)>> = encoded, _, _), do: Needle.ULID.decode(encoded)
  end

  if @pride_enabled do
    def dump(value, dumper, %{} = params), do: Pride.dump(value, dumper, params)
  end

  def dump(_, _, _), do: :error

  def dump!(encoded, dumper \\ nil, params \\ nil) do
    case dump(encoded, dumper, params) do
      {:ok, uid} -> uid
      _ -> raise Ecto.CastError, type: __MODULE__, value: encoded
    end
  end

  @doc """
  Converts a binary ID into an encoded string. Transforms database column data into runtime data.
  """
  @impl true
  def load(value, loader \\ nil, params \\ nil)
  def load(nil, _, _), do: {:ok, nil}

  if @pride_enabled do
    def load(value, loader, %{prefix: _} = params), do: Pride.load(value, loader, params)
  end

  if @pride_enabled do
    def load(value, loader, %{} = params) do
      with :error <- Pride.load(value, loader, params) do
        if @ulid_enabled do
          Needle.ULID.encode(value)
        else
          :error
        end
      end
    end
  end

  if @ulid_enabled do
    def load(bytes, _, _) when is_binary(bytes) and byte_size(bytes) == 16,
      do: Needle.ULID.encode(bytes)
  end

  def load(_, _, _), do: :error

  @doc """
  Takes a string and returns true if it is a valid UUID or ULID.

  ## Examples
      iex> valid?("01J3MQ2Q4RVB1WTE3KT1D8ZNX1")
      true

      iex> valid?("550e8400-e29b-41d4-a716-446655440000")
      true

      > is_pride?("test_3TUIKuXX5mNO2jSA41bsDx") and is_uuid?("test_3TUIKuXX5mNO2jSA41bsDx")
      true

      iex> valid?("invalid_id")
      false
  """
  def valid?(str, params \\ nil) do
    is_ulid?(str) || is_uuid?(str, params)
  end

  @doc """
  Takes a string and returns true if it is a valid ULID (Universally Unique Lexicographically Sortable Identifier).

  ## Examples
      iex> is_ulid?("01J3MQ2Q4RVB1WTE3KT1D8ZNX1")
      true

      iex> is_ulid?("invalid_ulid")
      false
  """
  def is_ulid?(str) when is_binary(str) and byte_size(str) == 26 do
    Needle.ULID.valid?(str)
  end

  def is_ulid?(_), do: false

  @doc """
  Takes a string and returns true if it is a valid Object ID or Prefixed UUID (Universally Unique Identifier).

  ## Examples
      iex> is_uuid?("550e8400-e29b-41d4-a716-446655440000")
      true

      > is_pride?("test_3TUIKuXX5mNO2jSA41bsDx") and is_uuid?("test_3TUIKuXX5mNO2jSA41bsDx")
      true

      iex> is_uuid?("invalid_uuid")
      false
      
  """
  def is_uuid?(str, params \\ nil)

  def is_uuid?(str, params) when is_binary(str) and byte_size(str) == 36 do
    with {:ok, _} <- Ecto.UUID.cast(str) do
      true
    else
      _ ->
      is_pride?(str, params)
    end
  end

  def is_uuid?(str, params), do: is_pride?(str, params)

  def is_pride?(str, params \\ nil)

  def is_pride?(str, params) do
    @pride_enabled && Pride.valid?(str, params)
  end

end