presence_ex

defmodule PresenceEx do
  @moduledoc false
  # credo:disable-for-this-file Credo.Check.Refactor.PipeChainStart

  import Ecto.Query
  alias PresenceEx.Repo
  alias PresenceEx.Schemas.Status
  alias PresenceEx.Utils
  alias PresenceEx.Schemas.Subscribe
  alias PresenceEx.Schemas.BeSubscribed

  def insert(account, resource, node, status, features) do
    %Status{}
    |> Status.changeset(%{
      account: account,
      resource: resource,
      node: node,
      status: status,
      features: features
    })
    |> Repo.insert(prefix: Utils.prefix(account))
  end

  def update(account, resource, t) do
    from(Status, where: [account: ^account, resource: ^resource])
    |> Repo.update_all([set: t], prefix: Utils.prefix(account))
  end

  def upsert(account, resource, node, status, features) do
    %Status{}
    |> Status.changeset(%{
      account: account,
      resource: resource,
      node: node,
      status: status,
      features: features
    })
    |> Repo.insert(
      prefix: Utils.prefix(account),
      on_conflict: {:replace, [:node, :status, :features]},
      conflict_target: [:account, :resource]
    )
  end

  @spec get(binary | integer, any) :: any
  def get(account, resource) do
    from(Status, where: [account: ^account, resource: ^resource])
    |> Repo.replica().all(prefix: Utils.prefix(account))
  end

  def get(account, resource, statuses) do
    case length(statuses) > 2 do
      true ->
        []

      false ->
        case statuses do
          [] ->
            []

          [s] ->
            from(Status, where: [account: ^account, resource: ^resource, status: ^s])
            |> Repo.replica().all(prefix: Utils.prefix(account))

          sl ->
            [s_exclude] = ["online", "away", "offline"] -- sl

            from(s in Status,
              where: s.account == ^account and s.resource == ^resource and s.status != ^s_exclude
            )
            |> Repo.replica().all(prefix: Utils.prefix(account))
        end
    end
  end

  def get_by_user(account) do
    from(Status, where: [account: ^account])
    |> Repo.replica().all(prefix: Utils.prefix(account))
  end

  def get_by_user(account, statuses) do
    case length(statuses) > 2 do
      true ->
        []

      false ->
        case statuses do
          [] ->
            []

          [s] ->
            from(Status, where: [account: ^account, status: ^s])
            |> Repo.replica().all(prefix: Utils.prefix(account))

          sl ->
            [s_exclude] = ["online", "away", "offline"] -- sl

            from(s in Status, where: s.account == ^account and s.status != ^s_exclude)
            |> Repo.replica().all(prefix: Utils.prefix(account))
        end
    end
  end

  def get_by_node(node) do
    query = from(Status, where: [node: ^node])

    Utils.all_schema_ids()
    |> Enum.flat_map(&Repo.replica().all(query, prefix: Utils.prefix(&1)))
  end

  def delete(account, resource) do
    from(Status, where: [account: ^account, resource: ^resource])
    |> Repo.delete_all(prefix: Utils.prefix(account))
  end

  def delete_by_user(account) do
    from(Status, where: [account: ^account])
    |> Repo.delete_all(prefix: Utils.prefix(account))
  end

  def delete_by_node(node) do
    query = from(Status, where: [node: ^node])

    Utils.all_schema_ids()
    |> Enum.map(&Repo.delete_all(query, prefix: Utils.prefix(&1)))
  end

  def upsert_subscribe(account, subscribe) do
    %Subscribe{}
    |> Subscribe.changeset(%{
      account: account,
      subscribe_map: subscribe
    })
    |> Repo.insert(
      prefix: Utils.prefix(account),
      on_conflict: {:replace, [:subscribe_map]},
      conflict_target: [:account]
    )
  end

  def get_subscribe(account) do
    from(Subscribe, where: [account: ^account])
    |> Repo.replica().all(prefix: Utils.prefix(account))
  end

  def delete_subscribe(account) do
    from(Subscribe, where: [account: ^account])
    |> Repo.delete_all(prefix: Utils.prefix(account))
  end

  def upsert_be_subscribed(account, subscribe) do
    %BeSubscribed{}
    |> BeSubscribed.changeset(%{
      account: account,
      be_subscribed_map: subscribe
    })
    |> Repo.insert(
      prefix: Utils.prefix(account),
      on_conflict: {:replace, [:be_subscribed_map]},
      conflict_target: [:account]
    )
  end

  def get_be_subscribed(account) do
    from(BeSubscribed, where: [account: ^account])
    |> Repo.replica().all(prefix: Utils.prefix(account))
  end

  def delete_be_subscribed(account) do
    from(BeSubscribed, where: [account: ^account])
    |> Repo.delete_all(prefix: Utils.prefix(account))
  end

  def start(_, _) do
    :ok
  end
end