import { RetellWebClient } from 'retell-client-js-sdk';

const retellClient = new RetellWebClient();

// Backend creates web call and returns access token
const response = await fetch(`${API_BASE}/api/retell/create-web-call`, {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ agentId: 'agent_xxxxx' }),
});

const { callId, accessToken } = await response.json();

// Start voice call in browser
await retellClient.startCall({ accessToken });

app.post('/api/retell/create-web-call', async (req, res) => {
  const { agentId } = req.body;
  const retellApiKey = process.env.RETELL_API_KEY;

  // Call Retell API to create web call
  const retellResponse = await fetch('https://api.retellai.com/v2/create-web-call', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${retellApiKey}`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ agent_id: agentId }),
  });

  const data = await retellResponse.json();
  
  return res.json({
    callId: data.call_id,
    accessToken: data.access_token,  // Short-lived token for client
    agentId: data.agent_id,
  });
});

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

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

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

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

  return { isEmergency, detectedSymptoms };
}

function calculateTriageLevel(symptoms: string[], isEmergency: boolean) {
  if (isEmergency) {
    return { level: 'emergency', score: 9 };
  }
  
  const urgentCount = symptoms.filter(s =>
    URGENT_KEYWORDS.some(kw => s.toLowerCase().includes(kw))
  ).length;
  
  if (urgentCount >= 2) return { level: 'urgent', score: 7 };
  if (urgentCount >= 1) return { level: 'urgent', score: 5 };
  if (symptoms.length > 0) return { level: 'routine', score: 3 };
  
  return { level: 'info', score: 1 };
}

interface TriageState {
  petName: string;           // "My dog Max is..."
  species: string;           // "cat", "dog", "rabbit"
  symptoms: string[];        // ["vomiting", "lethargy"]
  urgencyScore: number;      // 0-10
  triageLevel: TriageLevel;  // "emergency" | "urgent" | "routine" | "info"
  ownerName: string;         // Extracted from conversation
  phone: string;             // Captured during booking
  isEmergency: boolean;      // Triggers immediate vet notification
}

// Pet name detection from agent responses
const petNameMatch = agentText.match(/(?:meet|for|about|how is)\s+([A-Z][a-z]+)/);
// Matches: "Nice to meet Max" → "Max"

// Species detection from user text
const speciesMap = {
  dog: 'dog', puppy: 'dog',
  cat: 'cat', kitten: 'cat',
  bird: 'bird', rabbit: 'rabbit',
};

let detectedSpecies = '';
const lower = userText.toLowerCase();
for (const [key, val] of Object.entries(speciesMap)) {
  if (lower.includes(key)) {
    detectedSpecies = val;
    break;
  }
}

// Luna's internal logic (configured in Retell dashboard)
// Pseudo-code representation:

const availableSlots = await fetch('/api/appointments/available', {
  params: {
    date: requestedDate,
    duration: 30,  // Default appointment length
    veterinarian: preferredVet || 'any',
  },
}).json();

if (availableSlots.length === 0) {
  luna.speak("I don't see any openings that day. How about tomorrow at 2 PM?");
} else {
  luna.speak(`I have ${availableSlots[0].time} available. Does that work?`);
}

const appointmentBooked = transcript.some(t =>
  t.text.toLowerCase().includes('appointment') &&
  (t.text.toLowerCase().includes('book') || 
   t.text.toLowerCase().includes('schedule'))
);

if (appointmentBooked && petId) {
  const tomorrow = new Date();
  tomorrow.setDate(tomorrow.getDate() + 1);
  
  await supabase.from('appointments').insert({
    id: `appt-${Date.now()}`,
    pet_id: petId,
    pet_name: triageState.petName,
    owner_id: ownerId,
    owner_name: ownerName,
    type: triageState.isEmergency ? 'emergency' : 'wellness',
    reason: triageState.symptoms.join(', '),
    symptoms: triageState.symptoms,
    triage_level: triageState.triageLevel,
    scheduled_date: tomorrow.toISOString().split('T')[0],
    scheduled_time: '10:00',
    duration_minutes: 30,
    status: 'scheduled',
    notes: `Auto-created from AI call`,
  });
}

useEffect(() => {
  if (callState !== 'ended' || transcript.length === 0) return;

  const saveCallToDatabase = async () => {
    // Build transcript text
    const transcriptText = transcript
      .map(t => `${t.role === 'agent' ? 'AI' : 'Caller'}: ${t.text}`)
      .join('\n');

    // Generate summary
    const summary = triageState.petName
      ? `Call about ${triageState.petName} (${triageState.species}). Symptoms: ${triageState.symptoms.join(', ')}. Triaged as ${triageState.triageLevel}.`
      : `AI voice call — ${transcript.length} messages.`;

    const callRecord = {
      id: `call-${Date.now()}`,
      owner_id: ownerId,
      owner_name: ownerName || 'Unknown Caller',
      pet_name: triageState.petName || null,
      direction: 'inbound',
      status: triageState.isEmergency ? 'emergency' : 'completed',
      duration_seconds: callDuration,
      summary,
      triage_level: triageState.triageLevel,
      triage_keywords: triageState.symptoms,
      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);
  };

  saveCallToDatabase();
}, [callState]);