/**
 * E2E tests for CSV upload and session processing workflow
 *
 * Tests the complete data processing pipeline:
 * 1. CSV import configuration
 * 2. Data import and validation
 * 3. Session processing and AI analysis
 * 4. Dashboard visualization
 * 5. Data filtering and search
 */

import { test, expect, type Page } from "@playwright/test";

// Test data
const testAdmin = {
  email: "admin@csvtest.com",
  password: "AdminTestPassword123!",
};

const mockCsvData = `sessionId,userId,language,country,ipAddress,sentiment,messagesSent,startTime,endTime,escalated,forwardedHr,summary
session1,user1,en,US,192.168.1.1,positive,5,2024-01-15T10:00:00Z,2024-01-15T10:30:00Z,false,false,User requested vacation time
session2,user2,nl,NL,192.168.1.2,neutral,3,2024-01-15T11:00:00Z,2024-01-15T11:20:00Z,true,false,User had login issues
session3,user3,de,DE,192.168.1.3,negative,8,2024-01-15T12:00:00Z,2024-01-15T12:45:00Z,false,true,User complained about salary`;

// Helper functions
async function loginAsAdmin(page: Page) {
  await page.goto("http://localhost:3000/login");
  await page.fill('[data-testid="email"]', testAdmin.email);
  await page.fill('[data-testid="password"]', testAdmin.password);
  await page.click('[data-testid="login-button"]');
  await expect(page).toHaveURL(/\/dashboard/);
}

async function waitForDataProcessing(page: Page, timeout = 30000) {
  // Wait for processing indicators to disappear
  await page.waitForSelector('[data-testid="processing-indicator"]', {
    state: "hidden",
    timeout,
  });
}

async function setupMockCsvEndpoint(page: Page) {
  // Mock the CSV endpoint to return test data
  await page.route("**/test-csv-data", (route) => {
    route.fulfill({
      status: 200,
      contentType: "text/csv",
      body: mockCsvData,
    });
  });
}

test.describe("CSV Processing Workflow", () => {
  test.beforeEach(async ({ page }) => {
    // Setup mock CSV endpoint
    await setupMockCsvEndpoint(page);

    // Login as admin
    await loginAsAdmin(page);
  });

  test.describe("CSV Import Configuration", () => {
    test("should configure CSV import settings", async ({ page }) => {
      // Navigate to company settings
      await page.click('[data-testid="nav-company"]');
      await expect(page).toHaveURL(/\/dashboard\/company/);

      // Update CSV configuration
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.fill('[data-testid="csv-username"]', "testuser");
      await page.fill('[data-testid="csv-password"]', "testpass");

      // Save settings
      await page.click('[data-testid="save-settings"]');

      // Should show success message
      await expect(
        page.locator('[data-testid="success-message"]')
      ).toContainText("Settings saved successfully");
    });

    test("should validate CSV URL format", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/company");

      // Enter invalid URL
      await page.fill('[data-testid="csv-url"]', "invalid-url");
      await page.click('[data-testid="save-settings"]');

      // Should show validation error
      await expect(page.locator('[data-testid="csv-url-error"]')).toContainText(
        "Invalid URL format"
      );
    });
  });

  test.describe("Manual CSV Import", () => {
    test.beforeEach(async ({ page }) => {
      // Configure CSV settings first
      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.click('[data-testid="save-settings"]');
      await expect(
        page.locator('[data-testid="success-message"]')
      ).toBeVisible();
    });

    test("should trigger manual CSV import", async ({ page }) => {
      // Navigate to overview
      await page.goto("http://localhost:3000/dashboard/overview");

      // Trigger manual refresh
      await page.click('[data-testid="refresh-data-button"]');

      // Should show processing indicator
      await expect(
        page.locator('[data-testid="processing-indicator"]')
      ).toBeVisible();

      // Wait for processing to complete
      await waitForDataProcessing(page);

      // Should show success message
      await expect(
        page.locator('[data-testid="import-success"]')
      ).toContainText("Data imported successfully");
    });

    test("should display import progress", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/overview");

      // Start import
      await page.click('[data-testid="refresh-data-button"]');

      // Check progress indicators
      await expect(
        page.locator('[data-testid="import-progress"]')
      ).toBeVisible();

      // Progress should show stages
      await expect(
        page.locator('[data-testid="stage-csv-import"]')
      ).toContainText("CSV Import");
      await expect(
        page.locator('[data-testid="stage-processing"]')
      ).toContainText("Processing");
      await expect(
        page.locator('[data-testid="stage-ai-analysis"]')
      ).toContainText("AI Analysis");
    });

    test("should handle import errors gracefully", async ({ page }) => {
      // Configure invalid CSV URL
      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/nonexistent-csv"
      );
      await page.click('[data-testid="save-settings"]');

      // Try to import
      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');

      // Should show error message
      await expect(page.locator('[data-testid="import-error"]')).toContainText(
        "Failed to fetch CSV data"
      );
    });
  });

  test.describe("Data Visualization", () => {
    test.beforeEach(async ({ page }) => {
      // Import test data first
      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.click('[data-testid="save-settings"]');

      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');
      await waitForDataProcessing(page);
    });

    test("should display session metrics correctly", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/overview");

      // Check metric cards show correct data
      await expect(
        page.locator('[data-testid="total-sessions"]')
      ).toContainText("3");

      // Check sentiment distribution
      const sentimentChart = page.locator('[data-testid="sentiment-chart"]');
      await expect(sentimentChart).toBeVisible();

      // Verify sentiment data
      await expect(
        page.locator('[data-testid="positive-sentiment"]')
      ).toContainText("1");
      await expect(
        page.locator('[data-testid="neutral-sentiment"]')
      ).toContainText("1");
      await expect(
        page.locator('[data-testid="negative-sentiment"]')
      ).toContainText("1");
    });

    test("should display geographic distribution", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/overview");

      // Check geographic map
      const geoMap = page.locator('[data-testid="geographic-map"]');
      await expect(geoMap).toBeVisible();

      // Check country data
      await expect(page.locator('[data-testid="country-us"]')).toContainText(
        "US: 1"
      );
      await expect(page.locator('[data-testid="country-nl"]')).toContainText(
        "NL: 1"
      );
      await expect(page.locator('[data-testid="country-de"]')).toContainText(
        "DE: 1"
      );
    });

    test("should display escalation metrics", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/overview");

      // Check escalation rate
      await expect(
        page.locator('[data-testid="escalation-rate"]')
      ).toContainText("33%");

      // Check HR forwarding rate
      await expect(
        page.locator('[data-testid="hr-forwarding-rate"]')
      ).toContainText("33%");
    });
  });

  test.describe("Session Management", () => {
    test.beforeEach(async ({ page }) => {
      // Import test data
      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.click('[data-testid="save-settings"]');

      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');
      await waitForDataProcessing(page);
    });

    test("should display sessions list", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");

      // Should show all sessions
      await expect(page.locator('[data-testid="session-list"]')).toBeVisible();
      await expect(page.locator('[data-testid="session-item"]')).toHaveCount(3);

      // Check session details
      const firstSession = page.locator('[data-testid="session-item"]').first();
      await expect(firstSession).toContainText("session1");
      await expect(firstSession).toContainText("positive");
      await expect(firstSession).toContainText("US");
    });

    test("should filter sessions by sentiment", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");

      // Filter by positive sentiment
      await page.selectOption('[data-testid="sentiment-filter"]', "POSITIVE");

      // Should show only positive sessions
      await expect(page.locator('[data-testid="session-item"]')).toHaveCount(1);
      await expect(page.locator('[data-testid="session-item"]')).toContainText(
        "session1"
      );
    });

    test("should filter sessions by country", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");

      // Filter by Germany
      await page.selectOption('[data-testid="country-filter"]', "DE");

      // Should show only German sessions
      await expect(page.locator('[data-testid="session-item"]')).toHaveCount(1);
      await expect(page.locator('[data-testid="session-item"]')).toContainText(
        "session3"
      );
    });

    test("should search sessions by content", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");

      // Search for "vacation"
      await page.fill('[data-testid="search-input"]', "vacation");

      // Should show matching sessions
      await expect(page.locator('[data-testid="session-item"]')).toHaveCount(1);
      await expect(page.locator('[data-testid="session-item"]')).toContainText(
        "vacation time"
      );
    });

    test("should paginate sessions", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");

      // Set small page size
      await page.selectOption('[data-testid="page-size"]', "2");

      // Should show pagination
      await expect(page.locator('[data-testid="pagination"]')).toBeVisible();
      await expect(page.locator('[data-testid="session-item"]')).toHaveCount(2);

      // Go to next page
      await page.click('[data-testid="next-page"]');
      await expect(page.locator('[data-testid="session-item"]')).toHaveCount(1);
    });
  });

  test.describe("Session Details", () => {
    test.beforeEach(async ({ page }) => {
      // Import test data
      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.click('[data-testid="save-settings"]');

      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');
      await waitForDataProcessing(page);
    });

    test("should view individual session details", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");

      // Click on first session
      await page.click('[data-testid="session-item"]');

      // Should navigate to session detail page
      await expect(page).toHaveURL(/\/dashboard\/sessions\/[^/]+/);

      // Check session details
      await expect(page.locator('[data-testid="session-id"]')).toContainText(
        "session1"
      );
      await expect(
        page.locator('[data-testid="sentiment-badge"]')
      ).toContainText("positive");
      await expect(page.locator('[data-testid="country-badge"]')).toContainText(
        "US"
      );
      await expect(
        page.locator('[data-testid="session-summary"]')
      ).toContainText("vacation time");
    });

    test("should display session timeline", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");
      await page.click('[data-testid="session-item"]');

      // Check timeline
      const timeline = page.locator('[data-testid="session-timeline"]');
      await expect(timeline).toBeVisible();

      // Should show start and end times
      await expect(page.locator('[data-testid="start-time"]')).toContainText(
        "10:00"
      );
      await expect(page.locator('[data-testid="end-time"]')).toContainText(
        "10:30"
      );
      await expect(page.locator('[data-testid="duration"]')).toContainText(
        "30 minutes"
      );
    });

    test("should display extracted questions", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/sessions");
      await page.click('[data-testid="session-item"]');

      // Check questions section
      const questionsSection = page.locator(
        '[data-testid="extracted-questions"]'
      );
      await expect(questionsSection).toBeVisible();

      // Should show AI-extracted questions (if any)
      const questionsList = page.locator('[data-testid="questions-list"]');
      if (await questionsList.isVisible()) {
        await expect(
          questionsList.locator('[data-testid="question-item"]')
        ).toHaveCount.greaterThan(0);
      }
    });
  });

  test.describe("Real-time Updates", () => {
    test("should show real-time processing status", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/overview");

      // Configure CSV
      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.click('[data-testid="save-settings"]');

      // Start import and monitor status
      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');

      // Should show real-time status updates
      await expect(
        page.locator('[data-testid="status-importing"]')
      ).toBeVisible();

      // Status should progress through stages
      await page.waitForSelector('[data-testid="status-processing"]', {
        timeout: 10000,
      });
      await page.waitForSelector('[data-testid="status-analyzing"]', {
        timeout: 10000,
      });
      await page.waitForSelector('[data-testid="status-complete"]', {
        timeout: 30000,
      });
    });

    test("should update metrics in real-time", async ({ page }) => {
      await page.goto("http://localhost:3000/dashboard/overview");

      // Get initial metrics
      const initialSessions = await page
        .locator('[data-testid="total-sessions"]')
        .textContent();

      // Import data
      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.click('[data-testid="save-settings"]');

      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');
      await waitForDataProcessing(page);

      // Metrics should be updated
      const updatedSessions = await page
        .locator('[data-testid="total-sessions"]')
        .textContent();
      expect(updatedSessions).not.toBe(initialSessions);
    });
  });

  test.describe("Error Handling", () => {
    test("should handle CSV parsing errors", async ({ page }) => {
      // Mock invalid CSV data
      await page.route("**/invalid-csv", (route) => {
        route.fulfill({
          status: 200,
          contentType: "text/csv",
          body: "invalid,csv,format\nwithout,proper,headers",
        });
      });

      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/invalid-csv"
      );
      await page.click('[data-testid="save-settings"]');

      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');

      // Should show parsing error
      await expect(page.locator('[data-testid="parsing-error"]')).toContainText(
        "Invalid CSV format"
      );
    });

    test("should handle AI processing failures", async ({ page }) => {
      // Mock AI service failure
      await page.route("**/api/openai/**", (route) => {
        route.fulfill({
          status: 500,
          body: JSON.stringify({ error: "AI service unavailable" }),
        });
      });

      await page.goto("http://localhost:3000/dashboard/company");
      await page.fill(
        '[data-testid="csv-url"]',
        "http://localhost:3000/api/test-csv-data"
      );
      await page.click('[data-testid="save-settings"]');

      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');

      // Should show AI processing error
      await expect(page.locator('[data-testid="ai-error"]')).toContainText(
        "AI analysis failed"
      );
    });

    test("should retry failed operations", async ({ page }) => {
      let attemptCount = 0;

      // Mock failing then succeeding API
      await page.route("**/api/process-batch", (route) => {
        attemptCount++;
        if (attemptCount === 1) {
          route.fulfill({ status: 500, body: "Server error" });
        } else {
          route.fulfill({
            status: 200,
            body: JSON.stringify({ success: true }),
          });
        }
      });

      await page.goto("http://localhost:3000/dashboard/overview");
      await page.click('[data-testid="refresh-data-button"]');

      // Should show retry attempt
      await expect(
        page.locator('[data-testid="retry-indicator"]')
      ).toBeVisible();

      // Should eventually succeed
      await waitForDataProcessing(page);
      await expect(
        page.locator('[data-testid="import-success"]')
      ).toBeVisible();
    });
  });
});