import 'dotenv/config';

interface Issue {
  id: string;
  severity: 'error' | 'warning' | 'info';
  category: string;
  rule: string;
  message: string;
  selector?: string;
  wcag?: string;
  impact?: string;
  fix_suggestion?: string;
}

async function streamIssues(
  jobId: string,
  onIssue: (issue: Issue) => void
): Promise<void> {
  const response = await fetch(
    `https://vertaaux.ai/api/v1/audit/${jobId}/issues/stream`,
    {
      headers: {
        'X-API-Key': process.env.VERTAAUX_API_KEY!,
        'Accept': 'application/x-ndjson',
      },
    }
  );

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`Stream failed: ${error.message}`);
  }

  const reader = response.body?.getReader();
  if (!reader) throw new Error('No response body');

  const decoder = new TextDecoder();
  let buffer = '';

  while (true) {
    const { done, value } = await reader.read();

    if (done) break;

    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split('\n');

    // Process complete lines, keep incomplete line in buffer
    buffer = lines.pop() || '';

    for (const line of lines) {
      if (line.trim()) {
        const issue: Issue = JSON.parse(line);
        onIssue(issue);
      }
    }
  }

  // Process any remaining data
  if (buffer.trim()) {
    const issue: Issue = JSON.parse(buffer);
    onIssue(issue);
  }
}

// Usage
let errorCount = 0;
let warningCount = 0;

await streamIssues('clu1a2b3c4d5e6f7g8h9i0j1', (issue) => {
  console.log(`[${issue.severity.toUpperCase()}] ${issue.message}`);

  if (issue.severity === 'error') errorCount++;
  if (issue.severity === 'warning') warningCount++;
});

console.log(`\nTotal: ${errorCount} errors, ${warningCount} warnings`);

# Stream issues line by line
curl -N "https://vertaaux.ai/api/v1/audit/$JOB_ID/issues/stream" \
  -H "X-API-Key: $VERTAAUX_API_KEY" \
  -H "Accept: application/x-ndjson"

# Process each issue with jq
curl -N "https://vertaaux.ai/api/v1/audit/$JOB_ID/issues/stream" \
  -H "X-API-Key: $VERTAAUX_API_KEY" \
  -H "Accept: application/x-ndjson" | \
  while read -r line; do
    echo "$line" | jq -r '"\(.severity | ascii_upcase): \(.message)"'
  done

# Count issues by severity
curl -s "https://vertaaux.ai/api/v1/audit/$JOB_ID/issues/stream" \
  -H "X-API-Key: $VERTAAUX_API_KEY" \
  -H "Accept: application/x-ndjson" | \
  jq -s 'group_by(.severity) | map({severity: .[0].severity, count: length})'

import os
import json
import requests
from typing import Callable, TypedDict, Literal, Optional

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

def stream_issues(
    job_id: str,
    on_issue: Callable[[Issue], None]
) -> None:
    """Stream issues from an audit job."""
    response = requests.get(
        f'https://vertaaux.ai/api/v1/audit/{job_id}/issues/stream',
        headers={
            'X-API-Key': os.environ['VERTAAUX_API_KEY'],
            'Accept': 'application/x-ndjson',
        },
        stream=True
    )

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

    # Process stream line by line
    for line in response.iter_lines(decode_unicode=True):
        if line:
            issue: Issue = json.loads(line)
            on_issue(issue)

# Usage
issues_by_severity = {'error': 0, 'warning': 0, 'info': 0}

def handle_issue(issue: Issue) -> None:
    print(f"[{issue['severity'].upper()}] {issue['message']}")
    issues_by_severity[issue['severity']] += 1

stream_issues('clu1a2b3c4d5e6f7g8h9i0j1', handle_issue)

print(f"\nTotal: {issues_by_severity['error']} errors, "
      f"{issues_by_severity['warning']} warnings")