import 'dotenv/config';

interface AuditResult {
  job_id: string;
  status: 'queued' | 'running' | 'completed' | 'failed';
  url: string;
  progress: number;
  scores?: {
    overall: number;
    ux: number;
    accessibility: number;
    information_architecture: number;
    performance: number;
  };
  issues?: Array<{
    id: string;
    severity: 'error' | 'warning' | 'info';
    category: string;
    rule: string;
    message: string;
    selector?: string;
    wcag?: string;
  }>;
  total_issues?: number;
  error?: string;
}

async function pollAudit(
  jobId: string,
  intervalMs = 2000,
  maxAttempts = 60
): Promise<AuditResult> {
  const apiKey = process.env.VERTAAUX_API_KEY!;

  for (let attempt = 0; attempt < maxAttempts; attempt++) {
    const response = await fetch(
      `https://vertaaux.ai/api/v1/audit/${jobId}`,
      {
        headers: { 'X-API-Key': apiKey },
      }
    );

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`Failed to get audit: ${error.message}`);
    }

    const result: AuditResult = await response.json();

    if (result.status === 'completed') {
      return result;
    }

    if (result.status === 'failed') {
      throw new Error(`Audit failed: ${result.error}`);
    }

    console.log(`Progress: ${result.progress}%`);

    // Exponential backoff: increase interval after 10 attempts
    const delay = attempt > 10 ? intervalMs * 2 : intervalMs;
    await new Promise((resolve) => setTimeout(resolve, delay));
  }

  throw new Error('Audit timed out');
}

// Usage
const result = await pollAudit('clu1a2b3c4d5e6f7g8h9i0j1');
console.log(`Overall score: ${result.scores?.overall}`);
console.log(`Issues found: ${result.total_issues}`);

#!/bin/bash

JOB_ID="clu1a2b3c4d5e6f7g8h9i0j1"

while true; do
  RESULT=$(curl -s "https://vertaaux.ai/api/v1/audit/$JOB_ID" \
    -H "X-API-Key: $VERTAAUX_API_KEY")

  STATUS=$(echo "$RESULT" | jq -r '.status')
  PROGRESS=$(echo "$RESULT" | jq -r '.progress')

  if [ "$STATUS" = "completed" ]; then
    echo "Audit complete!"
    echo "$RESULT" | jq '{scores, total_issues}'
    break
  elif [ "$STATUS" = "failed" ]; then
    echo "Audit failed: $(echo "$RESULT" | jq -r '.error')"
    exit 1
  fi

  echo "Progress: $PROGRESS%"
  sleep 2
done

import os
import time
import requests
from typing import TypedDict, Literal, Optional

class Scores(TypedDict):
    overall: int
    ux: int
    accessibility: int
    information_architecture: int
    performance: int

class Issue(TypedDict):
    id: str
    severity: Literal['error', 'warning', 'info']
    category: str
    rule: str
    message: str
    selector: Optional[str]
    wcag: Optional[str]

class AuditResult(TypedDict):
    job_id: str
    status: Literal['queued', 'running', 'completed', 'failed']
    url: str
    progress: int
    scores: Optional[Scores]
    issues: Optional[list[Issue]]
    total_issues: Optional[int]
    error: Optional[str]

def poll_audit(
    job_id: str,
    interval_seconds: float = 2.0,
    max_attempts: int = 60
) -> AuditResult:
    """Poll for audit results with exponential backoff."""
    api_key = os.environ['VERTAAUX_API_KEY']

    for attempt in range(max_attempts):
        response = requests.get(
            f'https://vertaaux.ai/api/v1/audit/{job_id}',
            headers={'X-API-Key': api_key}
        )

        if not response.ok:
            error = response.json()
            raise Exception(f"Failed to get audit: {error.get('message')}")

        result: AuditResult = response.json()

        if result['status'] == 'completed':
            return result

        if result['status'] == 'failed':
            raise Exception(f"Audit failed: {result.get('error')}")

        print(f"Progress: {result['progress']}%")

        # Exponential backoff after 10 attempts
        delay = interval_seconds * 2 if attempt > 10 else interval_seconds
        time.sleep(delay)

    raise Exception('Audit timed out')

# Usage
result = poll_audit('clu1a2b3c4d5e6f7g8h9i0j1')
print(f"Overall score: {result['scores']['overall']}")
print(f"Issues found: {result['total_issues']}")