import { Page } from '@playwright/test';
import { LighthouseResult } from '../../types';

export class LighthouseRunner {
  constructor(private page: Page) {}

  async runLighthouse(url: string): Promise<LighthouseResult> {
    const results = await this.page.evaluate(async () => {
      return new Promise<LighthouseResult>((resolve) => {
        if (!(window as any).lighthouse) {
          resolve({
            performance: 0,
            accessibility: 0,
            bestPractices: 0,
            seo: 0,
            pwa: 0
          });
          return;
        }

        (window as any).lighthouse(url, {
          onlyCategories: ['performance', 'accessibility', 'best-practices', 'seo', 'pwa']
        }).then((result: any) => {
          resolve({
            performance: Math.round(result.categories.performance.score * 100),
            accessibility: Math.round(result.categories.accessibility.score * 100),
            bestPractices: Math.round(result.categories['best-practices'].score * 100),
            seo: Math.round(result.categories.seo.score * 100),
            pwa: Math.round(result.categories.pwa.score * 100)
          });
        });
      });
    });

    return results;
  }

  async runPerformanceAudit(): Promise<{
    score: number;
    metrics: {
      firstContentfulPaint: number;
      largestContentfulPaint: number;
      cumulativeLayoutShift: number;
      firstInputDelay: number;
      speedIndex: number;
    };
  }> {
    const results = await this.page.evaluate(async () => {
      return new Promise<{
        score: number;
        metrics: {
          firstContentfulPaint: number;
          largestContentfulPaint: number;
          cumulativeLayoutShift: number;
          firstInputDelay: number;
          speedIndex: number;
        };
      }>((resolve) => {
        if (!(window as any).lighthouse) {
          resolve({
            score: 0,
            metrics: {
              firstContentfulPaint: 0,
              largestContentfulPaint: 0,
              cumulativeLayoutShift: 0,
              firstInputDelay: 0,
              speedIndex: 0
            }
          });
          return;
        }

        (window as any).lighthouse(window.location.href, {
          onlyCategories: ['performance']
        }).then((result: any) => {
          resolve({
            score: Math.round(result.categories.performance.score * 100),
            metrics: {
              firstContentfulPaint: result.audits['first-contentful-paint'].numericValue,
              largestContentfulPaint: result.audits['largest-contentful-paint'].numericValue,
              cumulativeLayoutShift: result.audits['cumulative-layout-shift'].numericValue,
              firstInputDelay: result.audits['max-potential-fid'].numericValue,
              speedIndex: result.audits['speed-index'].numericValue
            }
          });
        });
      });
    });

    return results;
  }
}