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

/**
 * Performance Test Suite for SAWIS Business Intelligence Dashboard
 * Tests page load performance, data loading, and responsiveness
 */
test.describe('SAWIS Performance', () => {
  
  test('should load homepage within acceptable time', async ({ page }) => {
    // Start timing
    const startTime = Date.now();
    
    // Navigate to homepage
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    
    // Calculate load time
    const loadTime = Date.now() - startTime;
    
    // Verify load time is acceptable (less than 10 seconds)
    expect(loadTime).toBeLessThan(10000);
    
    // Verify page is functional
    await expect(page.getByRole('button', { name: 'Login' })).toBeVisible();
  });

  test('should load initial data within reasonable time', async ({ page }) => {
    // Navigate to homepage
    await page.goto('/');
    
    // Start timing for data load
    const startTime = Date.now();
    
    // Wait for key metrics to appear (indicating data has loaded)
    await page.waitForSelector('text=Total Export (l)', { timeout: 15000 });
    
    // Calculate data load time
    const dataLoadTime = Date.now() - startTime;
    
    // Verify data load time is acceptable (less than 15 seconds)
    expect(dataLoadTime).toBeLessThan(15000);
    
    // Verify data is displayed
    await expect(page.getByText('Total Export (l)')).toBeVisible();
  });

  test('should handle filter application performance', async ({ page }) => {
    // Navigate to homepage and wait for initial load
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Start timing
    const startTime = Date.now();
    
    // Apply a filter
    await page.getByText('Product Type').locator('..').getByText('7 options').click();
    await page.getByText('White').click();
    await page.getByRole('button', { name: 'Apply' }).click();
    
    // Wait for data to update
    await page.waitForTimeout(3000);
    
    // Calculate filter application time
    const filterTime = Date.now() - startTime;
    
    // Verify filter application time is acceptable (less than 8 seconds)
    expect(filterTime).toBeLessThan(8000);
    
    // Verify filter was applied
    await expect(page.getByText('Product Type').locator('..').getByText('1 selected')).toBeVisible();
  });

  test('should handle navigation performance', async ({ page }) => {
    // Navigate to homepage and wait for initial load
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Start timing
    const startTime = Date.now();
    
    // Navigate to Volume tab
    await page.getByRole('button', { name: 'Volume' }).click();
    await page.waitForTimeout(2000);
    
    // Calculate navigation time
    const navigationTime = Date.now() - startTime;
    
    // Verify navigation time is acceptable (less than 5 seconds)
    expect(navigationTime).toBeLessThan(5000);
    
    // Verify navigation was successful
    await expect(page.getByText('Total Export (l)')).toBeVisible();
  });

  test('should handle large dataset performance', async ({ page }) => {
    // Navigate to homepage and wait for initial load
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Start timing
    const startTime = Date.now();
    
    // Select all countries (large dataset)
    await page.getByText('Country').locator('..').getByText('194 options').click();
    await page.getByRole('button', { name: 'Select All' }).click();
    await page.getByRole('button', { name: 'Apply' }).click();
    
    // Wait for data to load
    await page.waitForTimeout(5000);
    
    // Calculate large dataset load time
    const largeDatasetTime = Date.now() - startTime;
    
    // Verify large dataset load time is acceptable (less than 20 seconds)
    expect(largeDatasetTime).toBeLessThan(20000);
    
    // Verify data is loaded
    await expect(page.getByText('Total Export (l)')).toBeVisible();
  });

  test('should handle rapid user interactions', async ({ page }) => {
    // Navigate to homepage and wait for initial load
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Perform rapid interactions
    const startTime = Date.now();
    
    // Rapidly click through navigation tabs
    await page.getByRole('button', { name: 'Volume' }).click();
    await page.waitForTimeout(500);
    await page.getByRole('button', { name: 'Value' }).click();
    await page.waitForTimeout(500);
    await page.getByRole('button', { name: 'Price Range' }).click();
    await page.waitForTimeout(500);
    await page.getByRole('button', { name: 'Overview' }).click();
    await page.waitForTimeout(500);
    
    const rapidInteractionTime = Date.now() - startTime;
    
    // Verify rapid interactions complete within reasonable time (less than 10 seconds)
    expect(rapidInteractionTime).toBeLessThan(10000);
    
    // Verify final state is correct
    await expect(page.getByText('Export market per product type')).toBeVisible();
  });

  test('should handle memory usage during extended use', async ({ page }) => {
    // Navigate to homepage
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Perform multiple operations to test memory usage
    for (let i = 0; i < 5; i++) {
      // Apply different filters
      await page.getByText('Year').locator('..').getByText('2025').click();
      await page.getByText(`${2020 + i}`).click();
      await page.getByRole('button', { name: 'Apply' }).click();
      await page.waitForTimeout(2000);
      
      // Navigate between tabs
      await page.getByRole('button', { name: 'Volume' }).click();
      await page.waitForTimeout(1000);
      await page.getByRole('button', { name: 'Overview' }).click();
      await page.waitForTimeout(1000);
    }
    
    // Verify page is still functional after extended use
    await expect(page.getByText('Export market per product type')).toBeVisible();
    await expect(page.getByRole('button', { name: 'Login' })).toBeVisible();
  });

  test('should handle network latency gracefully', async ({ page }) => {
    // Set slower network conditions
    await page.route('**/*', route => {
      // Add artificial delay to simulate slower network
      setTimeout(() => route.continue(), 1000);
    });
    
    // Navigate to homepage with slower network
    const startTime = Date.now();
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    
    const slowNetworkTime = Date.now() - startTime;
    
    // Verify page still loads (may take longer but should complete)
    expect(slowNetworkTime).toBeLessThan(30000);
    
    // Verify page is functional
    await expect(page.getByRole('button', { name: 'Login' })).toBeVisible();
  });

  test('should handle concurrent user interactions', async ({ page }) => {
    // Navigate to homepage
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Simulate concurrent interactions
    const startTime = Date.now();
    
    // Start multiple operations simultaneously
    const promises = [
      page.getByRole('button', { name: 'Volume' }).click(),
      page.getByText('Product Type').locator('..').getByText('7 options').click(),
      page.getByRole('button', { name: 'Login' }).click()
    ];
    
    await Promise.all(promises);
    await page.waitForTimeout(2000);
    
    const concurrentTime = Date.now() - startTime;
    
    // Verify concurrent operations complete within reasonable time
    expect(concurrentTime).toBeLessThan(10000);
    
    // Verify page is still functional
    await expect(page.getByText('Total Export (l)')).toBeVisible();
  });

  test('should handle browser back/forward navigation', async ({ page }) => {
    // Navigate to homepage
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Navigate to Volume tab
    await page.getByRole('button', { name: 'Volume' }).click();
    await page.waitForTimeout(2000);
    
    // Use browser back button
    await page.goBack();
    await page.waitForTimeout(2000);
    
    // Verify we're back on the homepage
    await expect(page.getByText('Export market per product type')).toBeVisible();
    
    // Use browser forward button
    await page.goForward();
    await page.waitForTimeout(2000);
    
    // Verify we're on the Volume tab
    await expect(page.getByText('Total Export (l)')).toBeVisible();
  });

  test('should handle page refresh performance', async ({ page }) => {
    // Navigate to homepage and apply some filters
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    await page.getByText('Product Type').locator('..').getByText('7 options').click();
    await page.getByText('White').click();
    await page.getByRole('button', { name: 'Apply' }).click();
    await page.waitForTimeout(2000);
    
    // Start timing
    const startTime = Date.now();
    
    // Refresh the page
    await page.reload();
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    const refreshTime = Date.now() - startTime;
    
    // Verify refresh time is acceptable
    expect(refreshTime).toBeLessThan(15000);
    
    // Verify page is functional after refresh
    await expect(page.getByText('Total Export (l)')).toBeVisible();
  });

  test('should handle resource loading performance', async ({ page }) => {
    // Listen for resource loading events
    const resources: string[] = [];
    page.on('response', response => {
      resources.push(response.url());
    });
    
    // Navigate to homepage
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    // Verify critical resources loaded
    expect(resources.length).toBeGreaterThan(0);
    
    // Check for failed resources
    const failedResources = resources.filter(url => url.includes('404') || url.includes('500'));
    expect(failedResources.length).toBeLessThan(5); // Allow for some expected 404s (like manifest.json)
    
    // Verify page is functional
    await expect(page.getByRole('button', { name: 'Login' })).toBeVisible();
  });

  test('should handle chart rendering performance', async ({ page }) => {
    // Navigate to homepage
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    
    // Start timing for chart rendering
    const startTime = Date.now();
    
    // Wait for charts to load
    await page.waitForTimeout(5000);
    
    // Check for chart elements
    const chartElements = page.locator('canvas, svg, [role="img"]');
    await expect(chartElements).toHaveCount.greaterThan(0);
    
    const chartRenderTime = Date.now() - startTime;
    
    // Verify chart rendering time is acceptable
    expect(chartRenderTime).toBeLessThan(10000);
    
    // Verify charts are functional
    await expect(page.getByText('Export market per product type')).toBeVisible();
  });

  test('should handle mobile performance', async ({ page }) => {
    // Set mobile viewport
    await page.setViewportSize({ width: 375, height: 667 });
    
    // Navigate to homepage
    const startTime = Date.now();
    await page.goto('/');
    await page.waitForLoadState('networkidle');
    await page.waitForTimeout(3000);
    
    const mobileLoadTime = Date.now() - startTime;
    
    // Verify mobile load time is acceptable
    expect(mobileLoadTime).toBeLessThan(12000);
    
    // Verify mobile functionality
    await expect(page.getByRole('button', { name: 'Login' })).toBeVisible();
    await expect(page.getByText('Total Export (l)')).toBeVisible();
  });
});