defmodule AiDebug.MoxIntegrationTest do
  use ExUnit.Case, async: true
  
  import Mox
  
  # Make sure mocks are verified on exit
  setup :verify_on_exit!
  
  describe "Mox integration verification" do
    test "Browser mock works correctly" do
      # Arrange
      browser_ref = make_ref()
      page_ref = make_ref()
      
      AiDebug.BrowserMock
      |> expect(:launch, fn opts ->
        assert Keyword.get(opts, :headless) == true
        assert Keyword.get(opts, :browser) == :chromium
        {:ok, browser_ref}
      end)
      |> expect(:new_page, fn ^browser_ref ->
        {:ok, page_ref}
      end)
      |> expect(:goto, fn ^page_ref, url, _opts ->
        assert url == "http://localhost:3000"
        {:ok, %{status: 200}}
      end)
      
      # Act
      assert {:ok, ^browser_ref} = AiDebug.BrowserMock.launch(headless: true, browser: :chromium)
      assert {:ok, ^page_ref} = AiDebug.BrowserMock.new_page(browser_ref)
      assert {:ok, %{status: 200}} = AiDebug.BrowserMock.goto(page_ref, "http://localhost:3000", [])
    end
    
    test "TestRunner mock works correctly" do
      # Arrange
      test_suite = %{
        id: "suite-123",
        name: "Test Suite",
        tests: [
          %{id: "t1", name: "Test 1", type: :unit, steps: []},
          %{id: "t2", name: "Test 2", type: :unit, steps: []}
        ]
      }
      
      expected_result = %{
        suite_id: "suite-123",
        status: :completed,
        total_tests: 2,
        passed: 2,
        failed: 0,
        skipped: 0,
        duration: 150,
        test_results: [
          %{id: "t1", status: :passed, duration: 50, error: nil},
          %{id: "t2", status: :passed, duration: 100, error: nil}
        ]
      }
      
      AiDebug.TestRunnerMock
      |> expect(:run_suite, fn ^test_suite, opts ->
        assert Keyword.get(opts, :parallel) == 4
        {:ok, expected_result}
      end)
      
      # Act
      assert {:ok, result} = AiDebug.TestRunnerMock.run_suite(test_suite, parallel: 4)
      
      # Assert
      assert result.suite_id == "suite-123"
      assert result.status == :completed
      assert result.total_tests == 2
      assert result.passed == 2
    end
    
    test "SessionManager mock works correctly" do
      # Arrange
      session_id = "session-456"
      
      AiDebug.SessionManagerMock
      |> expect(:create_session, fn opts ->
        assert Keyword.get(opts, :url) == "http://example.com"
        assert Keyword.get(opts, :browser) == :firefox
        {:ok, session_id}
      end)
      |> expect(:get_session, fn ^session_id ->
        {:ok, %{
          id: session_id,
          url: "http://example.com",
          status: :active,
          created_at: DateTime.utc_now(),
          updated_at: DateTime.utc_now(),
          metadata: %{}
        }}
      end)
      |> expect(:close_session, fn ^session_id ->
        :ok
      end)
      
      # Act
      assert {:ok, ^session_id} = AiDebug.SessionManagerMock.create_session(
        url: "http://example.com",
        browser: :firefox
      )
      
      assert {:ok, session} = AiDebug.SessionManagerMock.get_session(session_id)
      assert session.id == session_id
      assert session.status == :active
      
      assert :ok = AiDebug.SessionManagerMock.close_session(session_id)
    end
    
    test "multiple expectations work correctly" do
      # This tests that we can set up complex mock scenarios
      page_ref = make_ref()
      
      AiDebug.BrowserMock
      |> expect(:click, 2, fn ^page_ref, selector, _opts ->
        assert selector in ["#submit", "#cancel"]
        :ok
      end)
      |> expect(:type, fn ^page_ref, "#email", text, _opts ->
        assert text == "test@example.com"
        :ok
      end)
      
      # Act - simulating a form interaction
      assert :ok = AiDebug.BrowserMock.type(page_ref, "#email", "test@example.com", [])
      assert :ok = AiDebug.BrowserMock.click(page_ref, "#submit", [])
      assert :ok = AiDebug.BrowserMock.click(page_ref, "#cancel", [])
    end
  end
end