defmodule MvWeb.MemberLive.IndexPaymentPeriodTest do
  @moduledoc """
  §1.13 / §1.14 / §3.3 — the PaymentAging module: period parse/serialize with
  the all-outstanding default, badge formatting, and the open-cycles list that
  backs the badge tooltip (unpaid cycles for the period; suspended shown apart).
  """
  use Mv.DataCase, async: false

  import Mv.Fixtures, only: [create_fee_type: 2, member_fixture_with_actor: 2, create_cycle: 4]

  alias MvWeb.MemberLive.Index.PaymentAging

  require Ash.Query

  describe "period parsing / serialization" do
    test "default period is all-outstanding (both bounds nil)" do
      assert PaymentAging.default_period() == %{from: nil, to: nil}
    end

    test "no params parses to the default period" do
      assert PaymentAging.parse_period(%{}) == %{from: nil, to: nil}
    end

    test "parses ISO bounds and round-trips through to_params" do
      period = %{from: ~D[2024-01-01], to: ~D[2024-12-31]}
      params = PaymentAging.to_params(period)

      assert params["pay_from"] == "2024-01-01"
      assert params["pay_to"] == "2024-12-31"
      assert PaymentAging.parse_period(params) == period
    end

    test "default period serializes to no params" do
      assert PaymentAging.to_params(PaymentAging.default_period()) == %{}
    end

    test "malformed bounds fall back to nil" do
      assert PaymentAging.parse_period(%{"pay_from" => "not-a-date"}) == %{from: nil, to: nil}
    end
  end

  describe "badge/1" do
    test "0 renders as Paid (success)" do
      badge = PaymentAging.badge(0)
      assert badge.variant == :success
      assert badge.label == "Paid"
    end

    test "N > 0 renders as N unpaid (error)" do
      badge = PaymentAging.badge(2)
      assert badge.variant == :error
      assert badge.label =~ "2"
      assert badge.label =~ "unpaid"
    end
  end

  describe "open_cycles/2" do
    setup do
      actor = Mv.Helpers.SystemActor.get_system_actor()
      ft = create_fee_type(%{interval: :monthly}, actor)
      %{actor: actor, ft: ft}
    end

    test "lists in-period unpaid cycles and flags suspended separately; paid excluded",
         %{actor: actor, ft: ft} do
      member = member_fixture_with_actor(%{}, actor)
      create_cycle(member, ft, %{cycle_start: ~D[2024-01-01], status: :unpaid}, actor)
      create_cycle(member, ft, %{cycle_start: ~D[2024-02-01], status: :unpaid}, actor)
      create_cycle(member, ft, %{cycle_start: ~D[2024-03-01], status: :suspended}, actor)
      create_cycle(member, ft, %{cycle_start: ~D[2024-04-01], status: :paid}, actor)
      # out of period
      create_cycle(member, ft, %{cycle_start: ~D[2023-01-01], status: :unpaid}, actor)

      member = Ash.load!(member, :membership_fee_cycles, actor: actor)
      result = PaymentAging.open_cycles(member, %{from: ~D[2024-01-01], to: ~D[2024-12-31]})

      assert length(result.unpaid) == 2
      assert length(result.suspended) == 1
      assert Enum.all?(result.unpaid, &(&1.status == :unpaid))
      assert Enum.all?(result.suspended, &(&1.status == :suspended))
    end

    test "nil bounds include every unpaid/suspended cycle", %{actor: actor, ft: ft} do
      member = member_fixture_with_actor(%{}, actor)
      create_cycle(member, ft, %{cycle_start: ~D[2020-01-01], status: :unpaid}, actor)
      create_cycle(member, ft, %{cycle_start: ~D[2026-01-01], status: :suspended}, actor)

      member = Ash.load!(member, :membership_fee_cycles, actor: actor)
      result = PaymentAging.open_cycles(member, PaymentAging.default_period())

      assert length(result.unpaid) == 1
      assert length(result.suspended) == 1
    end
  end
end