defmodule AiDebugWeb.DashboardLiveTest do
  use AiDebugWeb.ConnCase, async: false
  import Phoenix.LiveViewTest

  describe "Dashboard LiveView" do
    test "renders dashboard with active sessions", %{conn: conn} do
      # Create test sessions
      {:ok, session1} = AiDebug.SessionManager.create_session("http://localhost:3000")
      {:ok, session2} = AiDebug.SessionManager.create_session("http://localhost:4000")

      {:ok, _view, html} = live(conn, "/")

      # Check dashboard renders
      assert html =~ "AI Debug Dashboard"
      assert html =~ "Active Sessions"
      
      # Check sessions are listed
      assert html =~ session1.id
      assert html =~ session2.id
      assert html =~ "localhost:3000"
      assert html =~ "localhost:4000"
    end

    test "shows real-time updates when session is created", %{conn: conn} do
      {:ok, view, _html} = live(conn, "/")

      # Create new session after mounting
      {:ok, session_info} = AiDebug.SessionManager.create_session("http://example.com")

      # Wait for update
      assert render(view) =~ session_info.id
      assert render(view) =~ "example.com"
    end

    test "allows creating new debug session", %{conn: conn} do
      {:ok, view, _html} = live(conn, "/")

      # Fill form and submit
      view
      |> form("#new-session-form", %{url: "http://test.com"})
      |> render_submit()

      # Check session was created
      assert render(view) =~ "test.com"
      assert render(view) =~ "Session created successfully"
    end

    test "displays browser pool status", %{conn: conn} do
      {:ok, _view, html} = live(conn, "/")

      assert html =~ "Browser Pool"
      assert html =~ "Available Browsers"
      assert html =~ "Active Browsers"
    end

    test "shows test execution progress", %{conn: conn} do
      {:ok, view, _html} = live(conn, "/")

      # Start a test suite
      test_suite = %{
        id: "test-123",
        name: "Homepage Tests",
        tests: [
          %{id: "t1", name: "Load test", type: :performance},
          %{id: "t2", name: "Visual test", type: :visual}
        ]
      }

      {:ok, _} = AiDebug.TestRunner.run_suite(test_suite)

      # Check progress updates
      assert render(view) =~ "Homepage Tests"
      assert render(view) =~ "Running"
      assert render(view) =~ "Load test"
      assert render(view) =~ "Visual test"
    end

    test "allows stopping a session", %{conn: conn} do
      {:ok, session_info} = AiDebug.SessionManager.create_session("http://localhost:3000")
      {:ok, view, _html} = live(conn, "/")

      # Click stop button
      view
      |> element("#session-#{session_info.id} button[phx-click=stop_session]")
      |> render_click()

      # Session should be removed
      refute render(view) =~ session_info.id
    end

    test "displays performance metrics", %{conn: conn} do
      {:ok, _view, html} = live(conn, "/")

      assert html =~ "Performance Metrics"
      assert html =~ "Session Creation Time"
      assert html =~ "Browser Checkout Time"
      assert html =~ "Active Workers"
    end

    test "shows error alerts", %{conn: conn} do
      {:ok, view, _html} = live(conn, "/")

      # Simulate error
      send(view.pid, {:error, "Browser pool exhausted"})

      assert render(view) =~ "Browser pool exhausted"
      assert render(view) =~ "alert-error"
    end

    test "live search for sessions", %{conn: conn} do
      {:ok, _session1} = AiDebug.SessionManager.create_session("http://app1.com")
      {:ok, _session2} = AiDebug.SessionManager.create_session("http://app2.com")
      {:ok, _session3} = AiDebug.SessionManager.create_session("http://other.com")

      {:ok, view, _html} = live(conn, "/")

      # Search for "app"
      view
      |> element("#session-search")
      |> render_change(%{search: "app"})

      html = render(view)
      assert html =~ "app1.com"
      assert html =~ "app2.com"
      refute html =~ "other.com"
    end

    test "displays detailed session information", %{conn: conn} do
      {:ok, session_info} = AiDebug.SessionManager.create_session("http://localhost:3000")
      session_id = session_info.id
      
      # Add some events to the session
      AiDebug.Session.add_event(session_id, %{
        type: "console",
        level: "error",
        message: "Test error"
      })

      {:ok, view, _html} = live(conn, "/session/#{session_id}")

      assert render(view) =~ "Session Details"
      assert render(view) =~ session_id
      assert render(view) =~ "localhost:3000"
      assert render(view) =~ "Test error"
      assert render(view) =~ "console"
    end
  end
end