class TwelveLabsService:
    def __init__(self, api_key=None):
        # If no API key is provided, try to get it from environment variable
        if api_key is None:
            api_key = os.environ.get('TWELVELABS_API_KEY', '')
        self.api_key = api_key # Store API key in the instance
        self.client = TwelveLabs(api_key=api_key) # Intialize the TwelveLabs client

def get_indexes(self):
        try:
            print("Fetching indexes...")
            # Check if API key is available
            if not self.api_key:
                print("No API key available")
                return []
            
            # Use TwelveLabs client to get a list of indexes
            indexes = self.client.indexes.list()
            
            result = []
            for index in indexes:
                # Append a dictionary with relevant index details
                result.append({
                    "id": index.id,
                    "name": index.index_name
                })
                print(f"ID: {index.id}")
                print(f"  Name: {index.index_name}")
            
            return result
        except Exception as e:
            print(f"Error fetching indexes: {e}")
            return []

def get_videos(self, index_id, page=1):
        try:
            # Check if API key is available
            if not self.api_key:
                print("No API key available")
                return []
            
            # Use TwelveLabs client to get a list of videos
            videos_response = self.client.indexes.videos.list(index_id=index_id, page=page)
            
            result = []
            for video in videos_response.items:
                system_metadata = video.system_metadata
                hls_data = video.hls
                thumbnail_urls = hls_data.get('thumbnail_urls', []) if hls_data else []
                thumbnail_url = thumbnail_urls[0] if thumbnail_urls else None
                video_url = hls_data.get('video_url') if hls_data else None
                # Append a dictionary with relevant video details
                result.append({
                    "id": video.id,
                    "name": system_metadata.filename if system_metadata and system_metadata.filename else f'Video {video.id}',
                    "duration": system_metadata.duration if system_metadata else 0,
                    "thumbnail_url": thumbnail_url,
                    "video_url": video_url,
                    "width": system_metadata.width if system_metadata else 0,
                    "height": system_metadata.height if system_metadata else 0,
                    "fps": system_metadata.fps if system_metadata else 0,
                    "size": system_metadata.size if system_metadata else 0
                })
            
            return result
        except Exception as e:
            print(f"Error fetching videos for index {index_id}: {e}")
            return []

def analyze_video(self, video_id, prompt):
        try:
            # Call the TwelveLabs client to analyze the video
            analysis_response = self.client.analyze(
                video_id=video_id,
                prompt=prompt
            )
            return analysis_response.data
        except Exception as e:
            print(f"Error analyzing video {video_id}: {e}")
            raise e

def deep_research(self, query, timeout=180):
        try:
            # Ensure API key is available
            if not self.api_key:
                raise ValueError("API key is required")
            
            payload = {
                "model": "sonar",
                "messages": [
                    {"role": "user", "content": query}
                ]
            }
            
            headers = {
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            }
            
            # POST request to the API endpoint with timeout
            response = requests.post(
                self.base_url, 
                json=payload, 
                headers=headers, 
                timeout=timeout
            )
            
            # Check if the response was successful
            if response.status_code == 200:
                return response.json()
            else:
                print(f"Error: {response.status_code} - {response.text}")
                return {"error": f"API request failed with status {response.status_code}"}
                
        except requests.exceptions.Timeout:
            print("Request timed out")
            return {"error": "Request timed out - Sonar research is taking too long"}
        except requests.exceptions.RequestException as e:
            print(f"Request error: {e}")
            return {"error": f"Network error: {str(e)}"}
        except Exception as e:
            print(f"Error in deep_research: {e}")
            return {"error": str(e)}

def generate_workflow(twelvelabs_api_key, index_id, video_id, analysis_prompt, research_query, research_prompt_template):
    # Input validation
    if not twelvelabs_api_key:
        yield json.dumps({'type': 'error', 'message': 'TwelveLabs API key is required'}) + '\n'
        return
    if not index_id or not video_id:
        yield json.dumps({'type': 'error', 'message': 'Index ID and Video ID are required'}) + '\n'
        return
    if not research_query:
        yield json.dumps({'type': 'error', 'message': 'Research query is required'}) + '\n'
        return

    try:
        twelvelabs_service = TwelveLabsService(api_key=twelvelabs_api_key)
        
        # Step 1: Get video details
        yield safe_json_dumps({
            'type': 'progress',
            'step': 'video_details',
            'message': 'Fetching video details...',
            'progress': 0
        }) + '\n'

        video_details = twelvelabs_service.get_video_details(index_id, video_id)
        if not video_details:
            yield safe_json_dumps({'type': 'error', 'message': 'Could not retrieve video details'}) + '\n'
            return

        yield safe_json_dumps({
            'type': 'data',
            'step': 'video_details',
            'data': {
                'id': video_details.get('_id', ''),
                'filename': video_details.get('system_metadata', {}).get('filename', ''),
                'duration': video_details.get('system_metadata', {}).get('duration', 0)
            },
            'progress': 33
        }) + '\n'

        # Step 2: Analyze video
        yield safe_json_dumps({
            'type': 'progress',
            'step': 'analysis',
            'message': 'Analyzing video content...',
            'progress': 33
        }) + '\n'

        analysis_result = twelvelabs_service.analyze_video(video_id, analysis_prompt)
        yield safe_json_dumps({
            'type': 'data',
            'step': 'analysis',
            'data': analysis_result,
            'progress': 66
        }) + '\n'

        # Step 3: Research with context
        yield safe_json_dumps({
            'type': 'progress',
            'step': 'research',
            'message': 'Conducting deep research...',
            'progress': 66
        }) + '\n'

        enhanced_query = research_prompt_template.format(
            analysis_result=analysis_result,
            research_query=research_query
        )
        
        sonar_service = SonarService()
        research_result = sonar_service.deep_research(enhanced_query, timeout=180)

        if 'error' in research_result:
            yield safe_json_dumps({'type': 'error', 'message': f'Research failed: {research_result["error"]}'}) + '\n'
            return

        # Extract research content
        research_content = ""
        if research_result and research_result.get('choices'):
            research_content = research_result['choices'][0].get('message', {}).get('content', '')
        
        # Send research content in chunks if large
        max_chunk_size = 10000
        if len(research_content) > max_chunk_size:
            for i in range(0, len(research_content), max_chunk_size):
                chunk = research_content[i:i + max_chunk_size]
                is_final = (i + max_chunk_size) >= len(research_content)
                
                yield safe_json_dumps({
                    'type': 'research_chunk',
                    'content': chunk,
                    'is_final': is_final,
                    'progress': 80 + (i / len(research_content)) * 20
                }) + '\n'
            
            # Send completion with chunked content indicator
            yield safe_json_dumps({
                'type': 'complete',
                'data': {
                    'research': {
                        'choices': [{
                            'message': {
                                'content': '[CHUNKED_CONTENT]'
                            }
                        }],
                        'citations': research_result.get('citations', [])[:10],
                        'usage': research_result.get('usage', {})
                    },
                    'sources': research_result.get('search_results', [])[:10]
                },
                'progress': 100
            }) + '\n'
        else:
            # Send completion with research data
            yield safe_json_dumps({
                'type': 'complete',
                'data': {
                    'research': {
                        'choices': [{
                            'message': {
                                'content': research_content
                            }
                        }],
                        'citations': research_result.get('citations', [])[:10],
                        'usage': research_result.get('usage', {})
                    },
                    'sources': research_result.get('search_results', [])[:10]
                },
                'progress': 100
            }) + '\n'

    except Exception as e:
        yield safe_json_dumps({'type': 'error', 'message': str(e)}) + '\n'

def upload_video_file(self, index_id: str, file_path: str, timeout_seconds: int = 900):
        import sys
        try:
            if not self.api_key:
                return {"error": "Missing TwelveLabs API key"}
            if not index_id:
                return {"error": "Missing index_id"}
            if not os.path.exists(file_path):
                return {"error": f"File not found: {file_path}"}
            
            print(f"Starting upload for file: {file_path}", file=sys.stderr)

            tasks_url = "https://api.twelvelabs.io/v1.3/tasks"
            headers = {
                "x-api-key": self.api_key
            }

            # Create upload task
            with open(file_path, "rb") as f:
                files = {
                    "video_file": (os.path.basename(file_path), f)
                }
                data = {
                    "index_id": index_id
                }
                resp = requests.post(tasks_url, headers=headers, files=files, data=data)

            if resp.status_code not in (200, 201):
                return {"error": f"Failed to create upload task: {resp.status_code} {resp.text}"}

            resp_json = resp.json() if resp.text else {}
            task_id = resp_json.get("id") or resp_json.get("task_id") or resp_json.get("_id")
            if not task_id:
                return {"error": f"No task id returned: {resp_json}"}

            # Poll task until ready
            import time
            start_time = time.time()
            print(f"Starting to poll task {task_id} for completion...", file=sys.stderr)
            
            while time.time() - start_time < timeout_seconds:
                r = requests.get(f"{tasks_url}/{task_id}", headers=headers)
                if r.status_code != 200:
                    time.sleep(2)
                    continue
                task = r.json() if r.text else {}
                status = task.get("status")
                print(f"Task {task_id} status: {status}", file=sys.stderr)
                
                if status in ("ready", "completed"):
                    video_id = task.get("video_id") or (task.get("data") or {}).get("video_id")
                    print(f"Indexing completed successfully! Video ID: {video_id}", file=sys.stderr)
                    return {"status": status, "video_id": video_id, "task": task}
                if status in ("failed", "error"):
                    print(f"Indexing failed with status: {status}", file=sys.stderr)
                    return {"error": f"Indexing failed with status {status}", "task": task}
                time.sleep(2)

            print(f"Upload timed out after {timeout_seconds} seconds", file=sys.stderr)
            return {"error": "Upload timed out"}