server.ts

import { serve } from '@hono/node-server';
import { Hono, Context } from 'hono';
import { ContentfulStatusCode } from 'hono/utils/http-status';
import { Innertube } from 'youtubei.js';

// Define interfaces for better type safety
interface TextRun {
  text: string;
}

interface Snippet {
  text?: string;
  runs?: TextRun[];
}

interface TranscriptSegmentRenderer {
  snippet?: Snippet;
  text?: string;
  runs?: TextRun[];
  start_ms?: string;
  end_ms?: string;
}

interface CueRenderer {
  cue_renderer?: {
    text?: Snippet;
    start_offset_ms?: string;
    duration_ms?: string;
  };
}

interface CueGroupRenderer {
  cue_group_renderer?: {
    cues?: CueRenderer[];
  };
}

// Interface for a more generic segment
interface GenericSegment {
  text?: string | Snippet;
  runs?: TextRun[];
  snippet?: Snippet;
  start_ms?: string;
  end_ms?: string;
  duration_ms?: string;
}

// A union type for the possible segment structures
type AnySegment = TranscriptSegmentRenderer | CueGroupRenderer | GenericSegment;

// Rate limiting store (in-memory for simple deployments)
interface RateLimitEntry {
  count: number;
  resetTime: number;
}

const rateLimitStore = new Map<string, RateLimitEntry>();
const RATE_LIMIT_WINDOW = 60 * 1000; // 60 seconds
const RATE_LIMIT_MAX = 5; // 5 requests per window

// Rate limiting function
const checkRateLimit = (ip: string): boolean => {
  const now = Date.now();
  const entry = rateLimitStore.get(ip);

  if (!entry || now > entry.resetTime) {
    // New window
    rateLimitStore.set(ip, {
      count: 1,
      resetTime: now + RATE_LIMIT_WINDOW
    });
    return true;
  }

  if (entry.count >= RATE_LIMIT_MAX) {
    return false;
  }

  entry.count++;
  return true;
};

// Cleanup old entries periodically
setInterval(() => {
  const now = Date.now();
  for (const [ip, entry] of rateLimitStore.entries()) {
    if (now > entry.resetTime) {
      rateLimitStore.delete(ip);
    }
  }
}, 60000); // Clean up every minute

// Helper function to decode HTML entities
const decodeHtmlEntities = (text: string | undefined | null): string => {
  if (!text) return '';
  return text
    .replace(/&amp;/g, '&')
    .replace(/&lt;/g, '<')
    .replace(/&gt;/g, '>')
    .replace(/&quot;/g, '"')
    .replace(/&#39;/g, "'")
    .replace(/&nbsp;/g, ' ');
};

// Helper function to extract text from different transcript segment formats
const extractTextFromSegment = (segment: AnySegment): string => {
  if (segment && 'transcript_segment_renderer' in segment && segment.transcript_segment_renderer) {
    const tsr = segment.transcript_segment_renderer as TranscriptSegmentRenderer;
    if (tsr.snippet?.text) return tsr.snippet.text;
    if (tsr.text) return tsr.text;
    if (tsr.snippet?.runs) return tsr.snippet.runs.map(run => run.text).join('');
    if (tsr.runs) return tsr.runs.map(run => run.text).join('');
  }
  if (segment && 'cue_group_renderer' in segment && segment.cue_group_renderer?.cues?.[0]?.cue_renderer) {
    const cue = segment.cue_group_renderer.cues[0].cue_renderer;
    if (cue.text?.text) return cue.text.text;
    if (cue.text?.runs) return cue.text.runs.map(run => run.text).join('');
  }
  if (segment && 'text' in segment && segment.text) {
    if (typeof segment.text === 'string') return segment.text;
    if (typeof segment.text === 'object') {
      const snippet = segment.text as Snippet;
      if (snippet.text) return snippet.text;
      if (snippet.runs) return snippet.runs.map(run => run.text).join('');
    }
  }
  if (segment && 'runs' in segment && Array.isArray(segment.runs)) {
    return (segment.runs as TextRun[]).map(run => run.text).join('');
  }
  if (segment && 'snippet' in segment && segment.snippet) {
    const snippet = segment.snippet as Snippet;
    if (snippet.text) return snippet.text;
    if (snippet.runs) return snippet.runs.map(run => run.text).join('');
  }
  return '';
};

// Helper function to extract video ID from YouTube URL
const extractVideoId = (urlOrId: string): string | null => {
  if (!urlOrId) return null;
  if (urlOrId.length === 11 && !urlOrId.includes('/') && !urlOrId.includes('?')) {
    return urlOrId;
  }
  try {
    const url = new URL(urlOrId);
    if (url.hostname === 'youtu.be') {
      return url.pathname.substring(1);
    }
    if (url.hostname === 'www.youtube.com' || url.hostname === 'youtube.com') {
      if (url.pathname === '/watch') {
        return url.searchParams.get('v');
      }
      if (url.pathname.startsWith('/embed/')) {
        return url.pathname.substring('/embed/'.length);
      }
      if (url.pathname.startsWith('/shorts/')) {
        return url.pathname.substring('/shorts/'.length);
      }
    }
  } catch (e) {
    console.error("Invalid URL or ID format attempting to parse:", urlOrId, e);
  }
  return null;
};

const app = new Hono();

// Health check endpoint
app.get('/health', (c: Context) => {
  return c.json({ status: 'ok', timestamp: new Date().toISOString() });
});

app.get('/', async (c: Context) => {
  // --- Rate Limiting Start ---
  // Get IP from various headers (Coolify/nginx may use different headers)
  const ipAddress =
    c.req.header('x-forwarded-for')?.split(',')[0].trim() ||
    c.req.header('x-real-ip') ||
    c.req.header('cf-connecting-ip') ||
    'unknown-ip';

  const rateLimitOk = checkRateLimit(ipAddress);

  if (!rateLimitOk) {
    console.log(`Rate limit exceeded for IP: ${ipAddress}`);
    return c.json({ error: "Rate limit exceeded. Please try again in a minute." }, 429);
  }
  // --- Rate Limiting End ---

  const videoUrlOrId = c.req.query('id');

  if (!videoUrlOrId) {
    return c.json({ error: "Video ID or URL is required (query param: 'id')" }, 400);
  }

  const videoId = extractVideoId(videoUrlOrId);

  if (!videoId) {
    return c.json({ error: "Invalid YouTube Video ID or URL format" }, 400);
  }

  try {
    console.log(`[${new Date().toISOString()}] Fetching transcript for video ID: ${videoId} from IP: ${ipAddress}`);
    const youtube = await Innertube.create();

    const info = await youtube.getInfo(videoId);
    const videoTitle = info.basic_info?.title || 'Untitled Video';
    const transcriptData = await info.getTranscript();

    if (!transcriptData || !transcriptData.transcript || !transcriptData.transcript.content ||
        !transcriptData.transcript.content.body || !transcriptData.transcript.content.body.initial_segments) {
      return c.json({ videoTitle, error: "No transcript available for this video." }, 404);
    }

    const segments = transcriptData.transcript.content.body.initial_segments || [];
    const formattedTranscript = segments.map((segment: AnySegment) => {
      let text = '';
      let offset = 0;
      let duration = 0;

      if (segment && 'transcript_segment_renderer' in segment && segment.transcript_segment_renderer) {
        const tsr = segment.transcript_segment_renderer as TranscriptSegmentRenderer;
        text = decodeHtmlEntities(extractTextFromSegment(tsr));
        offset = parseFloat(tsr.start_ms || '0') / 1000;
        duration = (parseFloat(tsr.end_ms || '0') - parseFloat(tsr.start_ms || '0')) / 1000;
      } else if (segment && 'cue_group_renderer' in segment && segment.cue_group_renderer?.cues?.[0]?.cue_renderer) {
        const cue = segment.cue_group_renderer.cues[0].cue_renderer;
        text = decodeHtmlEntities(extractTextFromSegment(cue));
        offset = parseFloat(cue.start_offset_ms || '0') / 1000;
        duration = parseFloat(cue.duration_ms || '0') / 1000;
      } else {
        text = decodeHtmlEntities(extractTextFromSegment(segment));
        offset = 0;
        duration = 0;
        const genericSegment = segment as GenericSegment;
        if (genericSegment.start_ms && typeof genericSegment.start_ms === 'string') {
          offset = parseFloat(genericSegment.start_ms) / 1000;
        }
        if (genericSegment.duration_ms && typeof genericSegment.duration_ms === 'string') {
          duration = parseFloat(genericSegment.duration_ms) / 1000;
        } else if (genericSegment.end_ms && typeof genericSegment.end_ms === 'string' &&
                   genericSegment.start_ms && typeof genericSegment.start_ms === 'string') {
          duration = (parseFloat(genericSegment.end_ms) - parseFloat(genericSegment.start_ms)) / 1000;
        }
      }
      return { text, offset, duration };
    }).filter((s: { text: string; offset: number; duration: number }) => s.text);

    console.log(`[${new Date().toISOString()}] Successfully fetched transcript for video ID: ${videoId} (${formattedTranscript.length} segments)`);
    return c.json({ videoTitle: decodeHtmlEntities(videoTitle), transcript: formattedTranscript });

  } catch (error: unknown) {
    const err = error as Error;
    console.error(`[${new Date().toISOString()}] Error fetching transcript for ${videoId}:`, err.message, err.stack);
    let errorMessage = "Failed to fetch transcript.";
    let statusCode: ContentfulStatusCode = 500;

    if (err instanceof SyntaxError && err.message.includes("JSON")) {
      errorMessage = "Failed to process data from YouTube. The API response may be malformed or incomplete.";
    } else if (err.message.includes('private') || err.message.includes('unavailable') || err.message.includes('premiere') || err.message.includes('live')) {
      errorMessage = "Video is private, unavailable, a live stream, or a premiere without a processed transcript.";
      statusCode = 403;
    } else if (err.message.includes(' অঞ্চলের কারণে') || err.message.includes('region-locked')) {
      errorMessage = "The video is region-locked and unavailable.";
      statusCode = 451;
    } else if (err.message.includes('Transcripts are not available for this video')) {
        errorMessage = "Transcripts are not available for this video.";
        statusCode = 404;
    }

    return c.json({ error: errorMessage, videoId }, statusCode);
  }
});

const port = parseInt(process.env.PORT || '3000');

console.log(`Server is running on port ${port}`);

serve({
  fetch: app.fetch,
  port
});