diffo

# SPDX-FileCopyrightText: 2025 diffo contributors <https://github.com/diffo-dev/diffo/graphs.contributors>
#
# SPDX-License-Identifier: MIT

defmodule Diffo.Provider.PartyRef do
  @moduledoc """
  Diffo - TMF Service and Resource Management with a difference

  PartyRef - Ash Resource for a TMF PartyRef
  """
  use Ash.Resource,
    otp_app: :diffo,
    domain: Diffo.Provider,
    data_layer: AshNeo4j.DataLayer,
    extensions: [AshOutstanding.Resource, AshJason.Resource]

  resource do
    description "An Ash Resource for a TMF Party Reference"
    plural_name :partyRefs
  end

  neo4j do
    relate [
      {:instance, :RELATES, :incoming, :Instance},
      {:place, :RELATES, :incoming, :Place},
      {:source_party, :RELATES, :incoming, :Party},
      {:party, :RELATES, :outgoing, :Party}
    ]
  end

  jason do
    pick [:role, :party]

    customize fn result, _record ->
      result
      |> Diffo.Util.extract_suppress(:party, :id, :id)
      |> Diffo.Util.extract_suppress(:party, :href, :href)
      |> Diffo.Util.extract_suppress(:party, :name, :name)
      |> Diffo.Util.extract_suppress(:party, :referredType, "@referredType")
      |> Diffo.Util.extract_suppress(:party, :type, "@type")
      |> Diffo.Util.remove(:party)
    end

    order [:id, :href, :name, :role, "@referredType", "@type"]
  end

  outstanding do
    expect [:party_id, :name, :role, :referredType, :type]
  end

  actions do
    defaults [:read, :destroy]

    create :create do
      description "creates a party ref, relating an instance, place or source party to a party"
      accept [:role]

      argument :instance_id, :uuid
      argument :place_id, :string
      argument :source_party_id, :string
      argument :party_id, :string

      change manage_relationship(:instance_id, :instance, type: :append_and_remove)
      change manage_relationship(:place_id, :place, type: :append_and_remove)
      change manage_relationship(:source_party_id, :source_party, type: :append_and_remove)
      change manage_relationship(:party_id, :party, type: :append_and_remove)
    end

    read :list do
      description "lists all party refs"
    end

    read :list_party_refs_by_instance_id do
      description "lists party refs by instance id"
      argument :instance_id, :uuid
      filter expr(instance_id == ^arg(:instance_id))
    end

    read :list_party_refs_by_place_id do
      description "lists party refs by place id"
      argument :place_id, :string
      filter expr(place_id == ^arg(:place_id))
    end

    read :list_party_refs_by_source_party_id do
      description "lists party refs by source_party id"
      argument :source_party_id, :string
      filter expr(source_party_id == ^arg(:source_party_id))
    end

    read :list_party_refs_by_party_id do
      description "lists party refs by party id"
      argument :party_id, :string
      filter expr(party_id == ^arg(:party_id))
    end

    read :find_by_party_id do
      description "finds party refs by party id"
      get? false

      argument :query, :ci_string do
        description "Return only party refs with party_ids including the given value."
      end

      filter expr(contains(party_id, ^arg(:query)))
    end

    update :update do
      description "updates the party ref role"
      accept [:role]
    end
  end

  attributes do
    uuid_primary_key :id do
      description "a uuid4, unique to this party ref, generated by default"
      public? false
    end

    attribute :role, :atom do
      description "the role of the party to the instance, place or source party"
      allow_nil? true
      public? true
    end

    create_timestamp :created_at

    update_timestamp :updated_at
  end

  relationships do
    belongs_to :instance, Diffo.Provider.Instance do
      description "the instance which relates to a party via this party ref"
      allow_nil? true
      public? true
    end

    belongs_to :place, Diffo.Provider.Place do
      description "the place which relates to a party via this party ref"
      attribute_type :string
      allow_nil? true
      public? true
    end

    belongs_to :source_party, Diffo.Provider.Party do
      description "the source party which relates to a party via this party ref"
      attribute_type :string
      allow_nil? true
      public? true
    end

    belongs_to :party, Diffo.Provider.Party do
      description "the party which is related from an instance via this party ref"
      attribute_type :string
      allow_nil? false
      public? true
    end
  end

  identities do
    identity :instance_party_uniqueness, [:instance_id, :party_id] do
      message "another party ref exists"
    end

    identity :place_party_uniqueness, [:place_id, :party_id] do
      message "another party ref exists"
    end

    identity :source_party_party_uniqueness, [:source_party_id, :party_id] do
      message "another party ref exists"
    end
  end

  validations do
    validate present([:instance_id, :place_id, :source_party_id], exactly: 1) do
      message "a party ref can relate either an instance, place or source party"
    end
  end

  preparations do
    prepare build(
              load: [:party],
              sort: [role: :asc, created_at: :desc]
            )
  end

  @doc """
  Assists in encoding party ref id
  """
  def id(result, record) do
    party = Map.get(record, :party)

    if is_struct(party, Diffo.Provider.Party) do
      id = Map.get(party, :id)

      if id != nil do
        result |> Diffo.Util.set(:id, id)
      else
        result
      end
    else
      result
    end
  end

  @doc """
  Compares two party ref, by ascending party_id
  ## Examples
    iex> Diffo.Provider.PartyRef.compare(%{party_id: "a"}, %{party_id: "a"})
    :eq
    iex> Diffo.Provider.PartyRef.compare(%{party_id: "b"}, %{party_id: "a"})
    :gt
    iex> Diffo.Provider.PartyRef.compare(%{party_id: "a"}, %{party_id: "b"})
    :lt

  """
  def compare(%{party_id: party_id0}, %{party_id: party_id1}),
    do: Diffo.Util.compare(party_id0, party_id1)
end