import express from 'express';
import twilio from 'twilio';

const app = express();
const VoiceResponse = twilio.twiml.VoiceResponse;

app.post('/webhooks/twilio/voice', express.urlencoded({ extended: false }), async (req, res) => {
  const { CallSid, From, To, Direction } = req.body;

  try {
    // Create a Kallglot session
    const session = await createKallglotSession({
      mode: 'bidirectional_translation',
      source_language: 'de',  // Customer's language
      target_language: 'en',  // Agent's language
      provider: {
        type: 'twilio',
        call_sid: CallSid
      },
      metadata: {
        from: From,
        to: To,
        direction: Direction
      }
    });

    // Generate TwiML to connect the call to Kallglot
    const response = new VoiceResponse();

    // Optional: Play a greeting
    response.say({
      language: 'de-DE'
    }, 'Willkommen. Ihr Anruf wird übersetzt.');

    // Connect to Kallglot media stream
    const connect = response.connect();
    connect.stream({
      url: session.stream.url,
      track: 'both_tracks'  // Send both inbound and outbound audio
    }).parameter({
      name: 'token',
      value: session.stream.token
    }).parameter({
      name: 'session_id',
      value: session.id
    });

    res.type('text/xml').send(response.toString());

  } catch (error) {
    console.error('Failed to create session:', error);

    // Fallback: connect to agent without translation
    const response = new VoiceResponse();
    response.say('Translation is temporarily unavailable. Connecting you now.');
    response.dial('+14155550123'); // Your agent's number

    res.type('text/xml').send(response.toString());
  }
});

app.listen(3000);

app.post('/webhooks/kallglot', express.json(), async (req, res) => {
  const event = req.body;

  switch (event.type) {
    case 'session.ended':
      // Session ended - save transcript, trigger analysis
      const { session_id, duration } = event.data;
      console.log(`Session ${session_id} ended after ${duration}s`);

      // Request analysis
      await requestKallglotAnalysis(session_id, {
        analyses: ['sentiment', 'summary', 'action_items']
      });
      break;

    case 'analysis.complete':
      // Analysis ready - store results
      const { results } = event.data;
      await db.calls.update({
        session_id: event.data.session_id,
        sentiment: results.sentiment.label,
        summary: results.summary.brief
      });
      break;
  }

  res.status(200).send('OK');
});

async function makeOutboundCall(customerPhone, agentPhone) {
  // 1. Create Kallglot session
  const session = await createKallglotSession({
    mode: 'bidirectional_translation',
    source_language: 'de',
    target_language: 'en'
  });

  // 2. Initiate outbound call via Twilio
  const call = await twilioClient.calls.create({
    url: `https://your-app.com/webhooks/twilio/outbound?session_id=${session.id}`,
    to: customerPhone,
    from: agentPhone
  });

  return { session, call };
}

// Webhook for outbound calls
app.post('/webhooks/twilio/outbound', async (req, res) => {
  const sessionId = req.query.session_id;
  const session = await retrieveKallglotSession(sessionId);

  const response = new VoiceResponse();
  const connect = response.connect();
  connect.stream({
    url: session.stream.url,
    track: 'both_tracks'
  }).parameter({
    name: 'token',
    value: session.stream.token
  });

  res.type('text/xml').send(response.toString());
});

app.post('/webhooks/twilio/conference', async (req, res) => {
  const { CallSid, ConferenceSid } = req.body;

  // Create session for this participant
  const session = await createKallglotSession({
    mode: 'bidirectional_translation',
    source_language: 'auto',  // Auto-detect each participant's language
    target_language: 'en'
  });

  const response = new VoiceResponse();
  const dial = response.dial();

  // Join conference with Kallglot stream
  dial.conference({
    statusCallback: '/webhooks/twilio/conference-status',
    record: 'record-from-start'
  }, 'TranslatedConference');

  // Start media stream
  response.connect().stream({
    url: session.stream.url
  }).parameter({
    name: 'token',
    value: session.stream.token
  });

  res.type('text/xml').send(response.toString());
});

const session = await createKallglotSession({
  mode: 'bidirectional_translation',
  source_language: 'auto',  // Auto-detect
  target_language: 'en'
});

// Listen for language detection event
session.on('language_detected', (data) => {
  console.log(`Detected language: ${data.language} (${data.confidence})`);
});

app.post('/webhooks/twilio/voice', async (req, res) => {
  try {
    const session = await createKallglotSession({
      // ...
    });
    // Return TwiML with stream
  } catch (error) {
    console.error('Kallglot error:', error);

    const response = new VoiceResponse();

    if (error.code === 'rate_limit_exceeded') {
      response.say('We are experiencing high call volume. Please try again later.');
      response.hangup();
    } else {
      // Fallback to non-translated call
      response.say('Translation service is temporarily unavailable.');
      response.dial('+14155550123');
    }

    res.type('text/xml').send(response.toString());
  }
});

app.post('/webhooks/twilio/stream-status', async (req, res) => {
  const { StreamSid, StreamStatus } = req.body;

  if (StreamStatus === 'stopped') {
    // Stream ended - end the Kallglot session
    const sessionId = await getSessionIdForStream(StreamSid);
    await endKallglotSession(sessionId);
  }

  res.status(200).send('OK');
});