import { test, expect } from '@playwright/test'

test.describe('Shadow Runs (KBX Foundation)', () => {
  test.beforeEach(async ({ page }) => {
    // Set up auth headers for development mode
    await page.goto('/model-ops/shadow-runs', {
      waitUntil: 'networkidle',
    })

    // Wait for component to hydrate
    await page.waitForTimeout(500)
  })

  test('should display shadow run list', async ({ page }) => {
    // Check page title
    const title = page.locator('h1')
    await expect(title).toContainText('Shadow Run Validation')

    // Check if grid is present
    const grid = page.locator('.ks-grid')
    await expect(grid).toBeVisible()

    // Check if summary items exist
    const summaryItems = page.locator('.ks-list-page__footer > span')
    await expect(summaryItems).toHaveCount(3)
  })

  test('should filter shadow runs by status', async ({ page }) => {
    // Get status filter select
    const statusFilter = page.locator('select.status-filter')
    await expect(statusFilter).toBeVisible()

    // Change filter
    await statusFilter.selectOption('completed')

    // Wait for filter to apply
    await page.waitForTimeout(500)

    // Check if grid is still visible
    const grid = page.locator('.ks-grid')
    await expect(grid).toBeVisible()
  })

  test('should navigate to shadow run detail', async ({ page }) => {
    // Wait for data to load
    await page.waitForTimeout(500)

    // Find first row in grid
    const firstRow = page.locator('.ag-row').first()
    await expect(firstRow).toBeVisible()

    // Click row
    await firstRow.click()

    // Check if we navigated to detail page
    await page.waitForURL('**/shadow-runs/*', { timeout: 5000 })
    expect(page.url()).toMatch(/\/model-ops\/shadow-runs\/.+/)

    // Verify detail page loaded
    const detailHeader = page.locator('.detail-header h1')
    await expect(detailHeader).toBeVisible()
  })

  test('should display validation summary', async ({ page }) => {
    // Navigate to detail
    const firstRow = page.locator('.ag-row').first()
    await expect(firstRow).toBeVisible()
    await firstRow.click()
    await page.waitForURL('**/shadow-runs/*')

    // Check validation section
    const validationSection = page.locator('.validation-summary')
    await expect(validationSection).toBeVisible()

    // Check metrics cards
    const metricCards = page.locator('.metric-card')
    await expect(metricCards.first()).toBeVisible()
  })

  test('should use F3 keyboard shortcut for search', async ({ page }) => {
    const searchInput = page.locator('input[placeholder*="Search"]').first()
    const initialValue = await searchInput.inputValue()

    // Press F3
    await page.keyboard.press('F3')

    // Should trigger search (component refetch)
    await page.waitForTimeout(300)

    // Verify search was triggered (mock API will respond)
    const grid = page.locator('.ks-grid')
    await expect(grid).toBeVisible()
  })

  test('should use Ctrl+N shortcut to create new shadow run', async ({ page }) => {
    // Press Ctrl+N
    await page.keyboard.press('Control+N')

    // Should navigate to new page (may redirect to home or form)
    // For now just verify no error occurred
    await expect(page).not.toHaveTitle('Error')
  })

  test('should show empty state when no results', async ({ page }) => {
    // Search for non-existent run
    const searchInput = page.locator('input[placeholder*="Search"]').first()
    await searchInput.fill('nonexistent')
    await searchInput.press('Enter')

    await page.waitForTimeout(500)

    // Should show empty message
    const emptyState = page.locator('[class*="empty"]')
    // Note: This depends on actual implementation
  })

  test('should persist filters across navigation', async ({ page }) => {
    // Set status filter
    const statusFilter = page.locator('select.status-filter')
    await statusFilter.selectOption('completed')

    // Navigate to detail
    await page.waitForTimeout(300)
    const firstRow = page.locator('tbody tr').first()
    if (await firstRow.isVisible()) {
      await firstRow.click()
      await page.waitForURL('**/shadow-runs/*')

      // Navigate back
      await page.goBack()
      await page.waitForURL('**/shadow-runs$')

      // Filter should be preserved (or reset based on implementation)
      await expect(statusFilter).toBeVisible()
    }
  })
})