if (!video.user_metadata ||
         Object.keys(video.user_metadata).length === 0 ||
          !video.user_metadata.topic_category &&
          !video.user_metadata.emotions && 
          !video.user_metadata.brands &&
          !video.user_metadata.locations)) {


       setVideosInProcessing(prev => [...prev, videoId]);


       const hashtagText = await generateMetadata(videoId);


       if (hashtagText) {
         const metadata = parseHashtags(hashtagText);

import { NextResponse } from 'next/server';


const API_KEY = process.env.TWELVELABS_API_KEY;
const TWELVELABS_API_BASE_URL = process.env.TWELVELABS_API_BASE_URL;


export const maxDuration = 60;


export async function GET(req: Request) {
   const { searchParams } = new URL(req.url);
   const videoId = searchParams.get("videoId");
   const prompt =
   `You are a marketing assistant specialized in generating hashtags for video content.


Based on the input video metadata, generate a list of hashtags labeled by category.


**Output Format:**
Each line must be in the format:
[Category]: [Hashtag]
(e.g., sector: #beauty)




**Allowed Values:**


Gender: Male, Female
Age: 18-25, 25-34, 35-44, 45-54, 55+
Topic: Beauty, Fashion, Tech, Travel, CPG, Food & Bev, Retail, Other
Emotions: sorrow, happiness, laughter, anger, empathy, fear, love, trust, sadness, belonging, guilt, compassion, pride


**Instructions:**


1. Use only the values provided in Allowed Values.
2. Do not invent new values except for Brands and Location. Only use values from the Allowed Values.
3. Output must contain at least one hashtag for each of the following categories:
 - Gender
 - Age
 - Topic
 - Emotions
 - Location
 - Brands


4. Do not output any explanations or category names—only return the final hashtag list.


**Output Example:**


Gender: female
Age: 25-34
Topic: beauty
Emotions: happiness
Location: Los Angeles
Brands: Fenty Beauty


---
`


  …


   const url = `${TWELVELABS_API_BASE_URL}/analyze`;
   const options = {
       method: "POST",
       headers: {
           "Content-Type": "application/json",
           "x-api-key": API_KEY,
       },
       body: JSON.stringify({
           prompt: prompt,
           video_id: videoId,
           stream: false
       })
   };


   try {
     const response = await fetch(url, options);
…

import { NextRequest, NextResponse } from 'next/server';
…


export async function PUT(request: NextRequest) {
 try {
   // Parse request body
   const body: MetadataUpdateRequest = await request.json();
   const { videoId, indexId, metadata } = body;
  …


   // Prepare API request
   const url = `${TWELVELABS_API_BASE_URL}/indexes/${indexId}/videos/${videoId}`;


   const requestBody = {
     user_metadata: {
       source: metadata.source || '',
       sector: metadata.sector || '',
       emotions: metadata.emotions || '',
       brands: metadata.brands || '',
       locations: metadata.locations || '',
       demographics: metadata.demographics || ''
     }
   };


   const options = {
     method: 'PUT',
     headers: {
       'Content-Type': 'application/json',
       'x-api-key': API_KEY,
     },
     body: JSON.stringify(requestBody)
   };


   // Call Twelve Labs API
   const response = await fetch(url, options);


…

 if (hashtagText) {
         const metadata = parseHashtags(hashtagText);


         await updateVideoMetadata(videoId, adsIndexId, metadata);

   // Fetch vectors using metadata filter instead of direct ID
   const queryResponse = await index.query({
     vector: new Array(1024).fill(0),
     filter: {
       tl_video_id: videoId
     },
     topK: 1,
     includeMetadata: true
   });


   return NextResponse.json({
     exists: queryResponse.matches.length > 0
   });

// Base URL
 let url = `${TWELVELABS_API_BASE_URL}/indexes/${indexId}/videos/${videoId}`;


 // Always include embedding query parameters if requested
 if (requestEmbeddings) {
   // Include only supported embedding options
   url += `?embedding_option=visual-text&embedding_option=audio`;
 }


 const options = {
   method: "GET",
   headers: {
     "x-api-key": `${API_KEY}`,
     "Accept": "application/json"
   },
 };


 try {
   const response = await fetch(url, options);

// Create vectors from embedding segments
   const vectors = embedding.video_embedding.segments.map((segment: Segment, index: number) => {
     // Create a meaningful and unique vector ID
     const vectorId = `${vectorIdBase}_segment${index + 1}`;


     const vector = {
       id: vectorId,
       values: segment.float,
       metadata: {
         video_file: actualFileName,
         video_title: videoTitle,
         video_segment: index + 1,
         start_time: segment.start_offset_sec,
         end_time: segment.end_offset_sec,
         scope: segment.embedding_scope,
         tl_video_id: videoId,
         tl_index_id: indexId,
         category
       }
     };


     return vector;
   });


   try {
     const index = getPineconeIndex();


     // Upload vectors in batches
     const batchSize = 100;
     const totalBatches = Math.ceil(vectors.length / batchSize);


     console.log(`🚀 FILENAME DEBUG - Starting vector upload with ${totalBatches} batches...`);


     for (let i = 0; i < vectors.length; i += batchSize) {
       const batch = vectors.slice(i, i + batchSize);
       const batchNumber = Math.floor(i / batchSize) + 1;


       try {
         // Test Pinecone connection before upserting
         try {
           await index.describeIndexStats();
         } catch (statsError) {
           console.error(`❌ Pinecone connection test failed:`, statsError);
           throw new Error(`Failed to connect to Pinecone: ${statsError instanceof Error ? statsError.message : 'Unknown error'}`);
         }


         // Perform the actual upsert
         await index.upsert(batch);

// Automatically check ONLY the ad video embedding when a video is selected
 useEffect(() => {
   if (selectedVideoId && !isLoadingEmbeddings) {
     const cachedStatus = queryClient.getQueryData(['embeddingStatus', selectedVideoId]) as
       { checked: boolean, ready: boolean } | undefined;


     if (!cachedStatus?.checked) {
       setIsLoadingEmbeddings(true);


       ensureEmbeddings().then(success => {
         queryClient.setQueryData(['embeddingStatus', selectedVideoId], {
           checked: true,
           ready: success
         });


         setEmbeddingsReady(success);
         setIsLoadingEmbeddings(false);
       });
     } else {
       setEmbeddingsReady(cachedStatus.ready);
     }
   }
 }, [selectedVideoId, isLoadingEmbeddings, queryClient]);

const handleContextualAnalysis = async () => {
  …
     try {
       textResults = await textToVideoEmbeddingSearch(selectedVideoId, adsIndexId, contentIndexId);
      …
     try {
       videoResults = await videoToVideoEmbeddingSearch(selectedVideoId, adsIndexId, contentIndexId);
…

// First, get the original video's clip embedding
   const originalClipQuery = await index.query({
     filter: {
       tl_video_id: videoId,
       scope: 'clip'
     },
     topK: 100,
     includeMetadata: true,
     includeValues: true,
     vector: new Array(1024).fill(0)
   });


   // If we found matching clips, search for similar ads for each match
   const similarResults = [];
   if (originalClipQuery.matches.length > 0) {
     for (const originalClip of originalClipQuery.matches) {
       const vectorValues = originalClip.values || new Array(1024).fill(0);
       const queryResult = await index.query({
         vector: vectorValues,
         filter: {
           tl_index_id: indexId,
           scope: 'clip'
         },
         topK: 5,
         includeMetadata: true,
       });
       similarResults.push(queryResult);
     }
   }

 if (combinedResultsMap.has(videoId)) {
           // This is a match found in both searches - update it
           const existingResult = combinedResultsMap.get(videoId);


           // Apply a significant boost for results found in both searches (50% boost)
           const boostMultiplier = 2;


           // Combine the scores: use the max of both scores and apply the boost
           const maxScore = Math.max(existingResult.textScore, result.score);
           const boostedScore = maxScore * boostMultiplier;


           combinedResultsMap.set(videoId, {
             ...existingResult,
             videoScore: result.score,
             finalScore: boostedScore,  // Boosted score for appearing in both searches
             source: "BOTH"
           });

 // Fetch chapters data
 const { data: chaptersData, isLoading: isChaptersLoading } = useQuery({
   queryKey: ["chapters", videoId],
   queryFn: () => generateChapters(videoId),
   enabled: isOpen && !!videoId,
 });

 const url = `${TWELVELABS_API_BASE_URL}/summarize`;
     const options = {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
             "x-api-key": `${API_KEY}`,
           },
           body: JSON.stringify({type: "chapter", video_id: videoId, prompt: "Chapterize this video into 3 chapters. For every chapter, describe why it is a strategically appropriate point for placing an advertisement. Do not mention what type of advertisement would be suitable, as the ad content has already been determined. "})
       };


     try {
       const response = await fetch(url, options);

export const generateChapters = async (videoId: string): Promise<ChaptersData> => {
 try {
   const response = await fetch(`/api/generateChapters?videoId=${videoId}`);

 // Chapter click handler
 const handleChapterClick = (index: number) => {
   if (playbackSequence === 'ad') {
     return;
   }


   if (!adVideoDetail?.hls?.video_url) {
     console.warn("No ad selected. Please select an ad in the contextual analysis page.");
     return;
   }


   if (!chaptersData) return;


   const chapter = chaptersData.chapters[index];
   setSelectedChapter(index);
   setHasPlayedAd(false);
   setPlaybackSequence('video');
   setShowChapterInfo(true);


   if (playerRef.current) {
     // Start 3 seconds before the chapter end time
     const startTime = Math.max(0, chapter.end - 3);
     playerRef.current.seekTo(startTime, 'seconds');
   }
 };

 // Track video progress
 const handleProgress = (state: { playedSeconds: number }) => {
   if (selectedChapter === null || !chaptersData || !adVideoDetail) {
     return;
   }


   const chapter = chaptersData.chapters[selectedChapter];
   const timeDiff = state.playedSeconds - chapter.end;
   const isLastChapter = selectedChapter === chaptersData.chapters.length - 1;


   if (
     playbackSequence === 'video' &&
     !hasPlayedAd &&
     ((isLastChapter && Math.abs(timeDiff) < 0.5) || (!isLastChapter && timeDiff >= 0))
   ) {
     setPlaybackSequence('ad');
     setHasPlayedAd(true);
   }
 };

 // Ad ended handler
 const handleAdEnded = () => {
   if (selectedChapter === null || !chaptersData) return;
   const chapter = chaptersData.chapters[selectedChapter];
   setPlaybackSequence('video');
   setReturnToTime(chapter.end);
   setIsPlaying(true);
 };