const EMERGENCY_KEYWORDS = [
  'bleeding',
  'seizure', 'seizures',
  'unconscious',
  'not breathing',
  'poisoned', 'poison',
  'hit by car',
  'broken bone',
  'choking',
  'collapse', 'collapsed',
  'convulsing',
  'bloat', 'swollen belly',
  'difficulty breathing', "can't breathe",
  'eaten chocolate', 'eaten rat poison',
];

const URGENT_KEYWORDS = [
  'vomiting',
  'diarrhea',
  'limping',
  "won't eat",
  'lethargic',
  'swelling',
  'eye injury',
  'pain', 'crying', 'whimpering',
  'blood in stool', 'blood in urine',
  'coughing',
  'difficulty walking',
];

function detectTriageFromText(text: string): {
  isEmergency: boolean;
  isUrgent: boolean;
  detectedSymptoms: string[];
} {
  const lower = text.toLowerCase();
  const detectedSymptoms: string[] = [];
  let isEmergency = false;
  let isUrgent = false;

  // Check emergency keywords
  for (const kw of EMERGENCY_KEYWORDS) {
    if (lower.includes(kw)) {
      detectedSymptoms.push(kw);
      isEmergency = true;
    }
  }

  // Check urgent keywords
  for (const kw of URGENT_KEYWORDS) {
    if (lower.includes(kw)) {
      detectedSymptoms.push(kw);
      isUrgent = true;
    }
  }

  return { isEmergency, isUrgent, detectedSymptoms };
}

function calculateTriageLevel(
  symptoms: string[],
  isEmergency: boolean
): { level: TriageLevel; score: number } {
  // Emergency keywords = automatic score 9
  if (isEmergency) {
    return { level: 'emergency', score: 9 };
  }

  // Count urgent symptoms
  const urgentCount = symptoms.filter(s =>
    URGENT_KEYWORDS.some(kw => s.toLowerCase().includes(kw))
  ).length;

  // Multiple urgent symptoms = higher priority
  if (urgentCount >= 2) return { level: 'urgent', score: 7 };
  if (urgentCount >= 1) return { level: 'urgent', score: 5 };

  // Symptoms present but not urgent
  if (symptoms.length > 0) return { level: 'routine', score: 3 };

  // No symptoms (informational call)
  return { level: 'info', score: 1 };
}

const updateTriageFromTranscript = useCallback((entries: TranscriptEntry[]) => {
  const fullText = entries.map(e => e.text).join(' ');
  const userText = entries.filter(e => e.role === 'user').map(e => e.text).join(' ');

  const { isEmergency, detectedSymptoms } = detectTriageFromText(fullText);
  const { level, score } = calculateTriageLevel(detectedSymptoms, isEmergency);

  // Extract pet name from agent text
  const agentText = entries.filter(e => e.role === 'agent').map(e => e.text).join(' ');
  const petNameMatch = agentText.match(/(?:meet|for|about|how is|patient)\s+([A-Z][a-z]+)/);

  // Detect species
  const speciesMap = {
    dog: 'dog', puppy: 'dog',
    cat: 'cat', kitten: 'cat',
    bird: 'bird', rabbit: 'rabbit',
  };
  let detectedSpecies = '';
  for (const [key, val] of Object.entries(speciesMap)) {
    if (userText.toLowerCase().includes(key)) {
      detectedSpecies = val;
      break;
    }
  }

  setTriageState(prev => ({
    ...prev,
    symptoms: [...new Set([...prev.symptoms, ...detectedSymptoms])],  // Dedupe
    urgencyScore: Math.max(prev.urgencyScore, score),  // Never decrease score
    triageLevel: score > prev.urgencyScore ? level : prev.triageLevel,
    isEmergency: prev.isEmergency || isEmergency,  // Once emergency, stays emergency
    petName: petNameMatch?.[1] || prev.petName,
    species: detectedSpecies || prev.species,
  }));
}, []);

<Card>
  <CardHeader>
    <CardTitle className="text-base flex items-center gap-2">
      <Activity className="h-4 w-4 text-primary" />
      Live Triage
    </CardTitle>
    <CardDescription>Auto-detected from conversation</CardDescription>
  </CardHeader>
  <CardContent>
    {/* Urgency Score Circle */}
    <div className="text-center">
      <div className={`inline-flex items-center justify-center w-20 h-20 rounded-full border-4 ${
        triageState.triageLevel === 'emergency' ? 'border-red-500 text-red-600' :
        triageState.triageLevel === 'urgent' ? 'border-orange-500 text-orange-600' :
        triageState.triageLevel === 'routine' ? 'border-green-500 text-green-600' :
        'border-blue-300 text-blue-500'
      }`}>
        <span className="text-2xl font-bold">{triageState.urgencyScore}</span>
      </div>
      <p className="text-sm text-muted-foreground mt-2">Urgency Score (0-10)</p>
      <Badge className={getTriageBadgeColor(triageState.triageLevel)}>
        {triageState.triageLevel.toUpperCase()}
      </Badge>
    </div>

    {/* Detected Symptoms */}
    {triageState.symptoms.length > 0 && (
      <div className="mt-4">
        <Label className="text-xs text-muted-foreground">Detected Symptoms</Label>
        <div className="flex flex-wrap gap-1 mt-2">
          {triageState.symptoms.map((s, i) => (
            <Badge key={i} variant="destructive" className="text-xs">{s}</Badge>
          ))}
        </div>
      </div>
    )}
  </CardContent>
</Card>

const callRecord = {
  id: `call-${Date.now()}`,
  owner_id: ownerId,
  owner_name: ownerName,
  pet_name: triageState.petName || null,
  direction: 'inbound',
  status: triageState.isEmergency ? 'emergency' : 'completed',
  duration_seconds: callDuration,
  summary: `Call about ${triageState.petName}. Symptoms: ${triageState.symptoms.join(', ')}. Triaged as ${triageState.triageLevel}.`,
  triage_level: triageState.triageLevel,  // 'emergency' | 'urgent' | 'routine' | 'info'
  triage_keywords: triageState.symptoms,  // String array
  transcript: transcriptText,
  started_at: new Date(Date.now() - callDuration * 1000).toISOString(),
  ended_at: new Date().toISOString(),
  appointment_booked: appointmentBooked ? 'pending' : null,
};

await supabase.from('calls').insert(callRecord);

CREATE TABLE calls (
  id TEXT PRIMARY KEY,
  owner_id UUID REFERENCES pet_owners(id),
  pet_name TEXT,
  triage_level TEXT CHECK (triage_level IN ('emergency', 'urgent', 'routine', 'info')),
  triage_keywords TEXT[],  -- Array of detected symptoms
  status TEXT,
  duration_seconds INTEGER,
  summary TEXT,
  transcript TEXT,
  started_at TIMESTAMPTZ,
  ended_at TIMESTAMPTZ
);

// In practice configuration (future feature)
const customEmergencyKeywords = [
  ...EMERGENCY_KEYWORDS,
  'twisted stomach',  // Layman's term for GDV
  'blue gums',        // Cyanosis indicator
  'heatstroke',
];

const customUrgentKeywords = [
  ...URGENT_KEYWORDS,
  'not jumping on couch',  // Practice-specific concern
  'not greeting at door',
];

// Configuration object
const triageConfig = {
  emergencyScore: 9,  // Default
  multipleUrgentThreshold: 2,  // How many urgent symptoms = high priority
  urgentHighScore: 7,
  urgentLowScore: 5,
};

if (urgentCount >= triageConfig.multipleUrgentThreshold) {
  return { level: 'urgent', score: triageConfig.urgentHighScore };
}