defmodule WorkloadService.Handlers.TaskCompletedHandler do
  use Commanded.Event.Handler,
    application: WorkloadService.CommandedApp,
    name: "TaskCompletedHandler"

  require Logger

  alias WorkloadService.Events.TaskCompleted
  alias Commanded.Aggregates.Aggregate
  alias WorkloadService.MessageBus

  alias WorkloadService.Aggregates.{
    QuoteTask,
    SolicitationTask
  }

def handle(%TaskCompleted{} = event, _metadata) do
    aggregate_module =
      case event.id.type do
        "quote" -> {:ok, QuoteTask}
        "solicitation" -> {:ok, SolicitationTask}
        _ -> {:error, "aggregate module not found for event type #{event.id}"}
      end

    case aggregate_module do
      {:error, reason} ->
        {:error, reason}

      {:ok, module} ->
        case Aggregate.aggregate_state(
               WorkloadService.CommandedApp,
               module,
               to_string(event.id)
             ) do
          nil ->
            Logger.warning("TaskCompletedHandler: aggregate not found for #{event.id}")

          state ->
            exchange =
              case event.id.type do
                "quote" -> "workload_service.events.quote_task_completed"
                "solicitation" -> "workload_service.events.solicitation_task_completed"
              end

            routing_key =
              case event.id.type do
                "quote" -> "quote_task.completed"
                "solicitation" -> "solicitation_task.completed"
              end

            MessageBus.publish(
              exchange,
              routing_key,
              state
            )

            Logger.info("TaskCompletedHandler: published for #{event.id}")
        end
    end
  end
end