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

  require Ash.Query

  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 "at least one member has no 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)

      # At least one member should have no membership_fee_type_id
      members_without_fee_type =
        Enum.filter(members, fn member -> member.membership_fee_type_id == nil end)

      assert not Enum.empty?(members_without_fee_type),
             "At least one member should have no membership fee type assigned"
    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 (excluding nil)
      members_by_fee_type =
        members
        |> Enum.filter(&(&1.membership_fee_type_id != nil))
        |> 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 not Enum.empty?(members_for_type),
               "Membership fee type #{fee_type.name} should have at least one member assigned"
      end)
    end

    test "members with fee types have cycles with various statuses" do
      # Run the seeds script
      assert Code.eval_file("priv/repo/seeds.exs")

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

      members_with_fee_types =
        members
        |> Enum.filter(&(&1.membership_fee_type_id != nil))

      # At least one member should have cycles
      assert not Enum.empty?(members_with_fee_types),
             "At least one member should have a membership fee type"

      # Check that cycles exist and have various statuses
      all_cycle_statuses =
        members_with_fee_types
        |> Enum.flat_map(fn member ->
          Mv.MembershipFees.MembershipFeeCycle
          |> Ash.Query.filter(member_id == ^member.id)
          |> Ash.read!()
        end)
        |> Enum.map(& &1.status)

      # At least one cycle should be paid
      assert :paid in all_cycle_statuses, "At least one cycle should be paid"
      # At least one cycle should be unpaid
      assert :unpaid in all_cycle_statuses, "At least one cycle should be unpaid"
      # At least one cycle should be suspended
      assert :suspended in all_cycle_statuses, "At least one cycle should be suspended"
    end
  end
end