defmodule Mv.SeedsTest do
  use Mv.DataCase, async: false

  describe "Seeds script" do
    test "runs successfully without errors" do
      # Run the seeds script - should not raise any errors
      assert Code.eval_file("priv/repo/seeds.exs")

      # Basic smoke test: ensure some data was created
      {:ok, users} = Ash.read(Mv.Accounts.User)
      {:ok, members} = Ash.read(Mv.Membership.Member)
      {:ok, custom_fields} = Ash.read(Mv.Membership.CustomField)

      assert not Enum.empty?(users), "Seeds should create at least one user"
      assert not Enum.empty?(members), "Seeds should create at least one member"
      assert not Enum.empty?(custom_fields), "Seeds should create at least one custom field"
    end

    test "can be run multiple times (idempotent)" do
      # Run seeds first time
      assert Code.eval_file("priv/repo/seeds.exs")

      # Count records
      {:ok, users_count_1} = Ash.read(Mv.Accounts.User)
      {:ok, members_count_1} = Ash.read(Mv.Membership.Member)
      {:ok, custom_fields_count_1} = Ash.read(Mv.Membership.CustomField)

      # Run seeds second time - should not raise errors
      assert Code.eval_file("priv/repo/seeds.exs")

      # Count records again - should be the same (upsert, not duplicate)
      {:ok, users_count_2} = Ash.read(Mv.Accounts.User)
      {:ok, members_count_2} = Ash.read(Mv.Membership.Member)
      {:ok, custom_fields_count_2} = Ash.read(Mv.Membership.CustomField)

      assert length(users_count_1) == length(users_count_2),
             "Users count should remain same after re-running seeds"

      assert length(members_count_1) == length(members_count_2),
             "Members count should remain same after re-running seeds"

      assert length(custom_fields_count_1) == length(custom_fields_count_2),
             "CustomFields count should remain same after re-running seeds"
    end

    test "all members have membership fee type assigned" do
      # Run the seeds script
      assert Code.eval_file("priv/repo/seeds.exs")

      # Get all members
      {:ok, members} = Ash.read(Mv.Membership.Member)

      # All members should have a membership_fee_type_id
      Enum.each(members, fn member ->
        assert member.membership_fee_type_id != nil,
               "Member #{member.first_name} #{member.last_name} should have a membership fee type assigned"
      end)
    end

    test "each membership fee type has at least one member" do
      # Run the seeds script
      assert Code.eval_file("priv/repo/seeds.exs")

      # Get all fee types and members
      {:ok, fee_types} = Ash.read(Mv.MembershipFees.MembershipFeeType)
      {:ok, members} = Ash.read(Mv.Membership.Member)

      # Group members by fee type
      members_by_fee_type =
        members
        |> Enum.group_by(& &1.membership_fee_type_id)

      # Each fee type should have at least one member
      Enum.each(fee_types, fn fee_type ->
        members_for_type = Map.get(members_by_fee_type, fee_type.id, [])

        assert length(members_for_type) > 0,
               "Membership fee type #{fee_type.name} should have at least one member assigned"
      end)
    end
  end
end