defmodule VavPipeline.EglahArufahTest do
  @moduledoc """
  Tests for the Eglah Arufah (Accountability Protocol).

  Devarim 21:7 — Yadeinu lo shafkhu et hadam hazeh, v'eineinu lo ra'u.
  "Our hands did not shed this blood, and our eyes did not see."
  Accountability for what was NOT provided. Not accusation.
  """

  use ExUnit.Case, async: false

  alias VavPipeline.EglahArufah

  @test_incident %{
    id: "unknown_harm_001",
    description: "User received corrupted output — source component unknown",
    approximate_location: "output_formatter",
    source: :unknown
  }

  @test_report %{
    processed: ["korban_042", "korban_043", "korban_044"],
    not_checked: ["output_encoding_validation", "character_set_verification"],
    could_have_caught: ["malformed_utf8_in_output"]
  }

  # ============================================================
  # Initiation — Devarim 21:1-3
  # ============================================================
  describe "initiate" do
    test "records a formal declaration for unknown harm" do
      {:ok, declaration} = EglahArufah.initiate(@test_incident, "output_formatter", @test_report)

      assert declaration.incident_id == "unknown_harm_001"
      assert declaration.component_id == "output_formatter"
      assert declaration.processed == ["korban_042", "korban_043", "korban_044"]
      assert declaration.not_checked == ["output_encoding_validation", "character_set_verification"]
      assert declaration.could_have_caught == ["malformed_utf8_in_output"]
      assert declaration.declared_at != nil
      assert String.contains?(declaration.declaration_text, "output_formatter")
      assert String.contains?(declaration.declaration_text, "did not cause this harm")
    end

    test "rejects incident with known source" do
      known_incident = Map.put(@test_incident, :source, :korban_processor)

      assert {:error, :source_not_unknown} =
               EglahArufah.initiate(known_incident, "output_formatter", @test_report)
    end

    test "declaration is permanently recorded" do
      EglahArufah.initiate(@test_incident, "permanent_test", @test_report)

      declarations = EglahArufah.declarations()
      assert Enum.any?(declarations, &(&1.component_id == "permanent_test"))
    end

    test "chatzotzrot assembly_leaders signal on initiation" do
      VavPipeline.Chatzotzrot.subscribe(:kohanim)

      EglahArufah.initiate(
        %{@test_incident | id: "signal_test_harm"},
        "signal_test_component",
        @test_report
      )

      assert_receive {:chatzotzrot, %{signal_type: :assembly_leaders}}
    end

    test "multiple declarations can exist for same incident" do
      incident = %{@test_incident | id: "multi_declare"}

      EglahArufah.initiate(incident, "component_a", %{
        processed: ["op1"],
        not_checked: ["check1"],
        could_have_caught: []
      })

      EglahArufah.initiate(incident, "component_b", %{
        processed: ["op2"],
        not_checked: [],
        could_have_caught: ["issue1"]
      })

      matching = EglahArufah.declarations_for("multi_declare")
      assert length(matching) == 2

      components = Enum.map(matching, & &1.component_id)
      assert "component_a" in components
      assert "component_b" in components
    end

    test "empty report lists are accepted" do
      {:ok, declaration} =
        EglahArufah.initiate(
          %{@test_incident | id: "empty_report"},
          "minimal_component",
          %{processed: [], not_checked: [], could_have_caught: []}
        )

      assert declaration.processed == []
      assert declaration.not_checked == []
      assert declaration.could_have_caught == []
    end
  end

  # ============================================================
  # Queries
  # ============================================================
  describe "queries" do
    test "declarations_for filters by incident_id" do
      EglahArufah.initiate(%{@test_incident | id: "filter_test"}, "comp_x", @test_report)
      EglahArufah.initiate(%{@test_incident | id: "other_incident"}, "comp_y", @test_report)

      result = EglahArufah.declarations_for("filter_test")
      assert length(result) >= 1
      assert Enum.all?(result, &(&1.incident_id == "filter_test"))
    end

    test "count returns total declarations" do
      initial = EglahArufah.count()
      EglahArufah.initiate(%{@test_incident | id: "count_test"}, "count_comp", @test_report)
      assert EglahArufah.count() == initial + 1
    end
  end
end