defmodule Mv.Helpers.SystemActorTest do
  @moduledoc """
  Tests for the SystemActor helper module.
  """
  use Mv.DataCase, async: false

  alias Mv.Helpers.SystemActor
  alias Mv.Authorization
  alias Mv.Accounts

  require Ash.Query

  # Helper function to ensure admin role exists
  defp ensure_admin_role do
    case Authorization.list_roles() do
      {:ok, roles} ->
        case Enum.find(roles, &(&1.permission_set_name == "admin")) do
          nil ->
            {:ok, role} =
              Authorization.create_role(%{
                name: "Admin",
                description: "Administrator with full access",
                permission_set_name: "admin"
              })

            role

          role ->
            role
        end

      _ ->
        {:ok, role} =
          Authorization.create_role(%{
            name: "Admin",
            description: "Administrator with full access",
            permission_set_name: "admin"
          })

        role
    end
  end

  # Helper function to ensure system user exists with admin role
  defp ensure_system_user(admin_role) do
    case Accounts.User
         |> Ash.Query.filter(email == ^"system@mila.local")
         |> Ash.read_one(domain: Mv.Accounts) do
      {:ok, user} when not is_nil(user) ->
        user
        |> Ash.Changeset.for_update(:update, %{})
        |> Ash.Changeset.manage_relationship(:role, admin_role, type: :append_and_remove)
        |> Ash.update!()
        |> Ash.load!(:role, domain: Mv.Accounts)

      _ ->
        Accounts.create_user!(%{email: "system@mila.local"},
          upsert?: true,
          upsert_identity: :unique_email
        )
        |> Ash.Changeset.for_update(:update, %{})
        |> Ash.Changeset.manage_relationship(:role, admin_role, type: :append_and_remove)
        |> Ash.update!()
        |> Ash.load!(:role, domain: Mv.Accounts)
    end
  end

  # Helper function to ensure admin user exists with admin role
  defp ensure_admin_user(admin_role) do
    admin_email = System.get_env("ADMIN_EMAIL") || "admin@localhost"

    case Accounts.User
         |> Ash.Query.filter(email == ^admin_email)
         |> Ash.read_one(domain: Mv.Accounts) do
      {:ok, user} when not is_nil(user) ->
        user
        |> Ash.Changeset.for_update(:update, %{})
        |> Ash.Changeset.manage_relationship(:role, admin_role, type: :append_and_remove)
        |> Ash.update!()
        |> Ash.load!(:role, domain: Mv.Accounts)

      _ ->
        Accounts.create_user!(%{email: admin_email},
          upsert?: true,
          upsert_identity: :unique_email
        )
        |> Ash.Changeset.for_update(:update, %{})
        |> Ash.Changeset.manage_relationship(:role, admin_role, type: :append_and_remove)
        |> Ash.update!()
        |> Ash.load!(:role, domain: Mv.Accounts)
    end
  end

  setup do
    admin_role = ensure_admin_role()
    system_user = ensure_system_user(admin_role)
    admin_user = ensure_admin_user(admin_role)

    # Invalidate cache to ensure fresh load
    SystemActor.invalidate_cache()

    %{admin_role: admin_role, system_user: system_user, admin_user: admin_user}
  end

  describe "get_system_actor/0" do
    test "returns system user with admin role", %{system_user: _system_user} do
      system_actor = SystemActor.get_system_actor()

      assert %Mv.Accounts.User{} = system_actor
      assert to_string(system_actor.email) == "system@mila.local"
      assert system_actor.role != nil
      assert system_actor.role.permission_set_name == "admin"
    end

    test "falls back to admin user if system user doesn't exist", %{admin_user: _admin_user} do
      # Delete system user if it exists
      case Accounts.User
           |> Ash.Query.filter(email == ^"system@mila.local")
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      # Invalidate cache to force reload
      SystemActor.invalidate_cache()

      # Should fall back to admin user
      system_actor = SystemActor.get_system_actor()

      assert %Mv.Accounts.User{} = system_actor
      assert system_actor.role != nil
      assert system_actor.role.permission_set_name == "admin"
      # Should be admin user, not system user
      assert to_string(system_actor.email) != "system@mila.local"
    end

    test "caches system actor for performance" do
      # First call
      actor1 = SystemActor.get_system_actor()

      # Second call should return cached actor (same struct)
      actor2 = SystemActor.get_system_actor()

      # Should be the same struct (cached)
      assert actor1.id == actor2.id
    end

    test "creates system user in test environment if none exists", %{admin_role: _admin_role} do
      # In test environment, system actor should auto-create if missing
      # Delete all users to test auto-creation
      case Accounts.User
           |> Ash.Query.filter(email == ^"system@mila.local")
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      admin_email = System.get_env("ADMIN_EMAIL") || "admin@localhost"

      case Accounts.User
           |> Ash.Query.filter(email == ^admin_email)
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      # Invalidate cache
      SystemActor.invalidate_cache()

      # Should auto-create system user in test environment
      system_actor = SystemActor.get_system_actor()

      assert %Mv.Accounts.User{} = system_actor
      assert to_string(system_actor.email) == "system@mila.local"
      assert system_actor.role != nil
      assert system_actor.role.permission_set_name == "admin"
    end
  end

  describe "invalidate_cache/0" do
    test "forces reload of system actor on next call" do
      # Get initial actor
      actor1 = SystemActor.get_system_actor()

      # Invalidate cache
      :ok = SystemActor.invalidate_cache()

      # Next call should reload (but should be same user)
      actor2 = SystemActor.get_system_actor()

      # Should be same user (same ID)
      assert actor1.id == actor2.id
    end
  end

  describe "get_system_actor_result/0" do
    test "returns ok tuple with system actor" do
      assert {:ok, actor} = SystemActor.get_system_actor_result()
      assert %Mv.Accounts.User{} = actor
      assert actor.role.permission_set_name == "admin"
    end

    test "returns error tuple when system actor cannot be loaded" do
      # Delete all users to force error
      case Accounts.User
           |> Ash.Query.filter(email == ^"system@mila.local")
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      admin_email = System.get_env("ADMIN_EMAIL") || "admin@localhost"

      case Accounts.User
           |> Ash.Query.filter(email == ^admin_email)
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      SystemActor.invalidate_cache()

      # In test environment, it should auto-create, so this should succeed
      # But if it fails, we should get an error tuple
      result = SystemActor.get_system_actor_result()

      # Should either succeed (auto-created) or return error
      assert match?({:ok, _}, result) or match?({:error, _}, result)
    end
  end

  describe "system_user_email/0" do
    test "returns the system user email address" do
      assert SystemActor.system_user_email() == "system@mila.local"
    end
  end

  describe "edge cases" do
    test "raises error if admin user has no role", %{admin_user: admin_user} do
      # Remove role from admin user
      admin_user
      |> Ash.Changeset.for_update(:update, %{})
      |> Ash.Changeset.manage_relationship(:role, nil, type: :append_and_remove)
      |> Ash.update!()

      # Delete system user to force fallback
      case Accounts.User
           |> Ash.Query.filter(email == ^"system@mila.local")
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      SystemActor.invalidate_cache()

      # Should raise error because admin user has no role
      assert_raise RuntimeError, ~r/System actor must have a role assigned/, fn ->
        SystemActor.get_system_actor()
      end
    end

    test "handles concurrent calls without race conditions" do
      # Delete system user and admin user to force creation
      case Accounts.User
           |> Ash.Query.filter(email == ^"system@mila.local")
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      admin_email = System.get_env("ADMIN_EMAIL") || "admin@localhost"

      case Accounts.User
           |> Ash.Query.filter(email == ^admin_email)
           |> Ash.read_one(domain: Mv.Accounts) do
        {:ok, user} when not is_nil(user) ->
          Ash.destroy!(user, domain: Mv.Accounts)

        _ ->
          :ok
      end

      SystemActor.invalidate_cache()

      # Call get_system_actor concurrently from multiple processes
      tasks =
        for _ <- 1..10 do
          Task.async(fn -> SystemActor.get_system_actor() end)
        end

      results = Task.await_many(tasks, :infinity)

      # All should succeed and return the same actor
      assert length(results) == 10
      assert Enum.all?(results, &(&1.role.permission_set_name == "admin"))
      assert Enum.all?(results, fn actor -> to_string(actor.email) == "system@mila.local" end)

      # All should have the same ID (same user)
      ids = Enum.map(results, & &1.id)
      assert Enum.uniq(ids) |> length() == 1
    end

    test "raises error if system user has wrong role", %{system_user: system_user} do
      # Create a non-admin role (using read_only as it's a valid permission set)
      {:ok, read_only_role} =
        Authorization.create_role(%{
          name: "Read Only Role",
          description: "Read-only access",
          permission_set_name: "read_only"
        })

      # Assign wrong role to system user
      system_user
      |> Ash.Changeset.for_update(:update, %{})
      |> Ash.Changeset.manage_relationship(:role, read_only_role, type: :append_and_remove)
      |> Ash.update!()

      SystemActor.invalidate_cache()

      # Should raise error because system user doesn't have admin role
      assert_raise RuntimeError, ~r/System actor must have admin role/, fn ->
        SystemActor.get_system_actor()
      end
    end

    test "raises error if system user has no role", %{system_user: system_user} do
      # Remove role from system user
      system_user
      |> Ash.Changeset.for_update(:update, %{})
      |> Ash.Changeset.manage_relationship(:role, nil, type: :append_and_remove)
      |> Ash.update!()

      SystemActor.invalidate_cache()

      # Should raise error because system user has no role
      assert_raise RuntimeError, ~r/System actor must have a role assigned/, fn ->
        SystemActor.get_system_actor()
      end
    end
  end
end