#!/usr/bin/env python3
"""
Debug script for summarization jobs (separate table)
"""
from app import app, db
from sqlalchemy import text
import sys
import os

def debug_summarization_job(job_uuid):
    with app.app_context():
        print(f"\n=== DEBUGGING SUMMARIZATION JOB {job_uuid} ===\n")
        
        try:
            # Query the summarization_jobs table directly
            query = text("SELECT * FROM summarization_jobs WHERE job_uuid = :uuid")
            result = db.session.execute(query, {'uuid': job_uuid}).fetchone()
            
            if not result:
                print("❌ Job not found in summarization_jobs table!")
                return None
            
            # Convert result to dict for easier access
            job_data = dict(result._mapping)
            
            print(f"📋 Summarization Job Details:")
            for key, value in job_data.items():
                print(f"  {key}: {value}")
            
            # Check if file exists
            file_path = job_data.get('file_path')
            if file_path and os.path.exists(file_path):
                file_size = os.path.getsize(file_path)
                print(f"\n✅ File exists: {file_size} bytes")
                print(f"  Path: {file_path}")
                
                # Check file type
                _, ext = os.path.splitext(file_path)
                print(f"  Extension: {ext}")
            else:
                print(f"\n❌ File missing: {file_path}")
            
            # Check for results
            results_query = text("SELECT * FROM summarization_results WHERE job_id = :job_id")
            results = db.session.execute(results_query, {'job_id': job_data.get('id')}).fetchone()
            
            if results:
                results_data = dict(results._mapping)
                print(f"\n📊 Results found:")
                for key, value in results_data.items():
                    if key == 'summary_text' and value:
                        print(f"  {key}: {len(value)} characters")
                        print(f"    Preview: {value[:200]}...")
                    else:
                        print(f"  {key}: {value}")
            else:
                print("\n❌ No results found")
            
            return job_data
            
        except Exception as e:
            print(f"❌ Error querying summarization job: {str(e)}")
            import traceback
            traceback.print_exc()
            return None

def reset_summarization_job(job_uuid, new_status='failed'):
    """Reset a stuck summarization job"""
    with app.app_context():
        try:
            # Update the job status
            update_query = text("""
                UPDATE summarization_jobs 
                SET status = :status, error_message = :error 
                WHERE job_uuid = :uuid
            """)
            
            error_msg = "Job manually reset due to timeout" if new_status == 'failed' else None
            
            db.session.execute(update_query, {
                'status': new_status,
                'error': error_msg,
                'uuid': job_uuid
            })
            db.session.commit()
            
            print(f"✅ Job status updated to '{new_status}'")
            
        except Exception as e:
            print(f"❌ Error updating job status: {str(e)}")

def test_summarization_processing(job_uuid):
    """Test the summarization processing for this specific job"""
    with app.app_context():
        print(f"\n🧪 Testing summarization processing...")
        
        # Get job details
        job_query = text("SELECT * FROM summarization_jobs WHERE job_uuid = :uuid")
        result = db.session.execute(job_query, {'uuid': job_uuid}).fetchone()
        
        if not result:
            print("❌ Job not found")
            return
        
        job_data = dict(result._mapping)
        file_path = job_data.get('file_path')
        summary_type = job_data.get('summary_type', 'standard')
        
        if not file_path or not os.path.exists(file_path):
            print(f"❌ File not found: {file_path}")
            return
        
        print(f"📁 Processing file: {file_path}")
        print(f"📋 Summary type: {summary_type}")
        
        try:
            # Test with your summarization processor
            from improved_document_processor import ImprovedDocumentProcessor
            
            api_key = app.config.get('OPENAI_API_KEY')
            if not api_key:
                print("❌ No OpenAI API key configured!")
                return
            
            processor = ImprovedDocumentProcessor(api_key=api_key)
            
            # Extract text first
            print("📝 Extracting text...")
            extracted_text = processor.extract_text_from_file(file_path)
            
            if not extracted_text:
                print("❌ Failed to extract text")
                return
            
            print(f"✅ Extracted {len(extracted_text)} characters")
            print(f"📖 Preview: {extracted_text[:200]}...")
            
            # Test basic summarization
            import openai
            client = openai.OpenAI(api_key=api_key)
            
            # Create appropriate prompt based on summary type
            if summary_type == "executive":
                prompt = f"Provide an executive summary of this document:\n\n{extracted_text[:3000]}"
            elif summary_type == "bullet_points":
                prompt = f"Summarize this document as bullet points:\n\n{extracted_text[:3000]}"
            else:  # standard
                prompt = f"Provide a comprehensive summary of this document:\n\n{extracted_text[:3000]}"
            
            print("🤖 Generating summary...")
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": "You are a professional document summarizer."},
                    {"role": "user", "content": prompt}
                ],
                max_tokens=1000,
                temperature=0.3
            )
            
            summary = response.choices[0].message.content
            print(f"✅ Generated summary ({len(summary)} characters):")
            print(f"📄 Summary: {summary[:300]}...")
            
            return summary
            
        except Exception as e:
            print(f"❌ Error during processing: {str(e)}")
            import traceback
            traceback.print_exc()
            return None

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python debug_summarization_job.py <job_uuid> [action]")
        print("Actions:")
        print("  info (default) - Show job information")
        print("  reset - Reset job to failed status")
        print("  test - Test processing the job manually")
        sys.exit(1)
    
    job_uuid = sys.argv[1]
    action = sys.argv[2] if len(sys.argv) > 2 else "info"
    
    if action == "info":
        debug_summarization_job(job_uuid)
    elif action == "reset":
        debug_summarization_job(job_uuid)
        reset_summarization_job(job_uuid, 'failed')
    elif action == "test":
        debug_summarization_job(job_uuid)
        test_summarization_processing(job_uuid)
    else:
        print(f"Unknown action: {action}")