import gradio as gr
import os
from semantic_search import CVSemanticSearch
import logging

# Set up logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Google Drive Configuration - UPDATE THESE VALUES
FOLDER_ID = "1j1faOlXxoYfPLdzDfGvDbtkENsRoDxXN"  # Replace with your folder ID
API_KEY = os.getenv("GOOGLE_DRIVE_API_KEY")  # Replace with your API key

# Global variables to store the search system and file mapping
cv_search = None
file_mapping = {}
initialization_status = "Initializing..."

def initialize_database():
    """
    Initialize the database by loading CVs from Google Drive folder
    This runs once when the space starts
    """
    global cv_search, initialization_status, file_mapping
    
    try:
        logger.info("Initializing CV Semantic Search system...")
        cv_search = CVSemanticSearch()
        
        logger.info("Loading CVs from Google Drive folder...")
        successful, total, file_map = cv_search.load_cvs_from_google_drive(FOLDER_ID, API_KEY)
        file_mapping = file_map
        
        if successful > 0:
            initialization_status = f"✅ Successfully loaded {successful}/{total} CVs into database"
            logger.info(initialization_status)
            return True
        else:
            initialization_status = "❌ Failed to load any CVs from Google Drive. Check API key and folder ID."
            logger.error(initialization_status)
            return False
            
    except Exception as e:
        initialization_status = f"❌ Error during initialization: {str(e)}"
        logger.error(initialization_status)
        return False

def process_job_description(jd_text, jd_file):
    """
    Process job description from either text input or PDF file
    
    Args:
        jd_text: Job description as text
        jd_file: Job description as PDF file
        
    Returns:
        Processed job description text
    """
    # Priority: PDF file over text input
    if jd_file is not None:
        try:
            with open(jd_file.name, 'rb') as f:
                pdf_content = f.read()
            
            extracted_text = cv_search.extract_text_from_pdf_bytes(pdf_content)
            if extracted_text.strip():
                return extracted_text.strip()
        except Exception as e:
            logger.error(f"Error processing JD PDF: {str(e)}")
    
    # Fallback to text input
    if jd_text and jd_text.strip():
        return jd_text.strip()
    
    return ""

def search_matching_cvs(jd_text, jd_file, num_results):
    """
    Search for CVs matching the job description
    
    Args:
        jd_text: Job description as text
        jd_file: Job description as PDF file
        num_results: Number of results to return
        
    Returns:
        Formatted search results
    """
    global cv_search, file_mapping
    
    if cv_search is None:
        return f"❌ System not initialized properly.\n\n{initialization_status}\n\nPlease refresh the page or check the configuration."
    
    # Process job description
    job_description = process_job_description(jd_text, jd_file)
    
    if not job_description:
        return "❌ Please provide a job description either as text or upload a PDF file."
    
    # Get database info
    db_info = cv_search.get_database_info()
    
    if db_info['unique_cvs'] == 0:
        return f"❌ No CVs in database.\n\n{initialization_status}"
    
    # Perform search
    results = cv_search.search_cvs(job_description, top_k=num_results)
    
    if not results:
        return "❌ No matching CVs found. Try using different keywords or requirements in your job description."
    
    # Format results
    jd_preview = job_description[:150] + "..." if len(job_description) > 150 else job_description
    
    output = f"""# 🎯 Top {len(results)} Matching CVs

**Job Description**: {jd_preview}

---

"""
    
    for i, cv in enumerate(results, 1):
        similarity_percentage = cv['weighted_score'] * 100
        filename = cv['filename']
        
        # Get Google Drive link
        drive_link = "Not available"
        if filename in file_mapping:
            drive_link = file_mapping[filename]['webViewLink']
        
        # Determine match quality
        if similarity_percentage >= 80:
            match_emoji = "🟢"
            match_text = "Excellent Match"
        elif similarity_percentage >= 65:
            match_emoji = "🟡"
            match_text = "Good Match"
        elif similarity_percentage >= 50:
            match_emoji = "🟠"
            match_text = "Fair Match"
        else:
            match_emoji = "🔴"
            match_text = "Weak Match"
        
        output += f"""## {i}. {filename}

**{match_emoji} {match_text}** - **{similarity_percentage:.1f}% Overall Match**

📊 **Detailed Scores:**
- Best Section Match: {cv['max_similarity']*100:.1f}%
- Average Match: {cv['avg_similarity']*100:.1f}%
- CV Sections Analyzed: {cv['chunk_count']}

💡 **Why This CV Matches:**
*"{cv['best_match_text']}"*

🔗 **[Open CV in Google Drive]({drive_link})**

---

"""
    
    return output

def get_system_status():
    """
    Get current system status
    
    Returns:
        System information as formatted string
    """
    global cv_search, initialization_status
    
    if cv_search is None:
        return f"""
## ⚠️ System Status: Not Ready

{initialization_status}

**Possible Issues:**
- Invalid Google Drive API key
- Incorrect folder ID  
- Folder is not public
- No PDF files in the folder
        """
    
    db_info = cv_search.get_database_info()
    
    if db_info['unique_cvs'] == 0:
        return f"""
## ⚠️ System Status: No CVs Loaded

{initialization_status}

**Please Check:**
- Google Drive folder contains PDF files
- Folder is publicly accessible  
- API key has proper permissions
        """
    
    return f"""
## ✅ System Status: Ready for Search

📊 **Database Statistics:**
- **CVs Loaded**: {db_info['unique_cvs']} resumes
- **Text Chunks**: {db_info['total_chunks']} searchable segments  
- **Avg Chunks per CV**: {db_info['total_chunks'] / db_info['unique_cvs']:.1f}

🤖 **AI Model**: Sentence Transformers (all-MiniLM-L6-v2)

📁 **Sample CVs**: {', '.join(db_info['cv_filenames'][:3])}{'...' if len(db_info['cv_filenames']) > 3 else ''}
    """

# Create Gradio interface
def create_interface():
    """Create and return the Gradio interface"""
    
    with gr.Blocks(
        title="CV Semantic Search - Auto-loaded from Google Drive",
        theme=gr.themes.Soft(),
        css="""
        .main-container { 
            max-width: 1200px; 
            margin: auto; 
            padding: 20px; 
        }
        .search-container { 
            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
            color: white !important; 
            padding: 30px; 
            border-radius: 20px; 
            margin: 20px 0;
            box-shadow: 0 10px 30px rgba(0,0,0,0.2);
        }
        .search-container * {
            color: white !important;
        }
        .status-container { 
            background: #f8f9fa !important; 
            color: #333 !important;
            padding: 25px; 
            border-radius: 15px; 
            margin: 20px 0; 
            border-left: 5px solid #007bff; 
            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
        }
        .status-container * {
            color: #333 !important;
        }
        .results-container { 
            background: #ffffff !important; 
            color: #333 !important;
            padding: 25px; 
            border-radius: 15px; 
            border: 1px solid #dee2e6; 
            margin: 20px 0; 
            box-shadow: 0 5px 15px rgba(0,0,0,0.1);
        }
        .results-container * {
            color: #333 !important;
        }
        .header { 
            text-align: center; 
            padding: 30px; 
            background: linear-gradient(135deg, #74b9ff, #0984e3); 
            color: white !important; 
            margin: -20px -20px 20px -20px; 
            border-radius: 15px 15px 0 0; 
        }
        .header * {
            color: white !important;
        }
        .tab-content { 
            padding: 15px; 
        }
        .markdown-content {
            background: #fff !important;
            color: #333 !important;
            padding: 20px;
            border-radius: 10px;
        }
        .markdown-content * {
            color: #333 !important;
        }
        """
    ) as demo:
        
        with gr.Column(elem_classes=["main-container"]):
            
            gr.Markdown("""
            <div class="header">
            
            # 🚀 CV Semantic Search System
            ## AI-Powered Resume Matching
            ### *Automatically synced with Google Drive*
            
            </div>
            """)
            
            # System Status Display
            with gr.Row():
                status_display = gr.Markdown(
                    get_system_status(),
                    elem_classes=["status-container", "markdown-content"]
                )
            
            # Main Search Interface
            with gr.Row():
                with gr.Column():
                    with gr.Group(elem_classes=["search-container"]):
                        gr.Markdown("## 📋 Job Description Input")
                        
                        with gr.Tab("📝 Text Input") as text_tab:
                            jd_text = gr.Textbox(
                                label="Paste Job Description",
                                placeholder="""Paste your job description here...

Example:
Senior Software Engineer Position

Requirements:
• 5+ years of experience in Python, JavaScript, and React
• Strong background in machine learning and AI
• Experience with cloud platforms (AWS, Azure, GCP)
• Knowledge of microservices and API development
• Bachelor's degree in Computer Science or related field
• Excellent problem-solving and communication skills

Responsibilities:
• Design and develop scalable web applications
• Lead technical projects and mentor junior developers
• Collaborate with cross-functional teams
• Implement best practices for code quality and testing""",
                                lines=12,
                                max_lines=20,
                                elem_classes=["tab-content"]
                            )
                        
                        with gr.Tab("📄 PDF Upload") as pdf_tab:
                            jd_file = gr.File(
                                label="Upload Job Description PDF",
                                file_types=[".pdf"],
                                file_count="single",
                                elem_classes=["tab-content"]
                            )
                        
                        with gr.Row():
                            num_results = gr.Slider(
                                label="Number of Top CVs to Return",
                                minimum=1,
                                maximum=10,
                                value=5,
                                step=1
                            )
                        
                        search_btn = gr.Button(
                            "🔍 Find Best Matching CVs",
                            variant="primary",
                            size="lg"
                        )
            
            # Search Results
            with gr.Row():
                search_output = gr.Markdown(
                    """
# 📋 How to Use This System:

1. **Enter Job Requirements**: Use the text box or upload a PDF with your job description
2. **Click Search**: The AI will analyze semantic meaning and find the best matches  
3. **Review Results**: See ranked CVs with detailed similarity scores and explanations

## 🎯 What Makes This Special:
- **Semantic Understanding**: Finds relevant CVs even if they don't use exact keywords
- **Automatic Sync**: CVs are always up-to-date from your Google Drive folder
- **Smart Ranking**: Combines multiple similarity metrics for accurate results
- **Detailed Analysis**: Shows why each CV matches your requirements

*Enter a job description above to get started!*
                    """,
                    elem_classes=["results-container", "markdown-content"]
                )
            
            # Refresh Status Button
            with gr.Row():
                refresh_btn = gr.Button("🔄 Refresh System Status", size="sm")
        
        # Event handlers
        search_btn.click(
            fn=search_matching_cvs,
            inputs=[jd_text, jd_file, num_results],
            outputs=[search_output]
        )
        
        refresh_btn.click(
            fn=get_system_status,
            outputs=[status_display]
        )
        
        # Clear text input when PDF is uploaded
        jd_file.change(
            fn=lambda: "",
            outputs=[jd_text]
        )
        
        # Clear file input when text is entered
        jd_text.change(
            fn=lambda x: None if x.strip() else None,
            inputs=[jd_text],
            outputs=[jd_file]
        )
        
        # Footer
        gr.Markdown("""
---
# 🛠️ Technical Details

- **Vector Database**: ChromaDB (rebuilt on each restart)
- **Embedding Model**: SentenceTransformers all-MiniLM-L6-v2  
- **Text Extraction**: pdfplumber + OCR fallback for scanned documents
- **CV Source**: Google Drive folder (automatically synced)
- **Search Algorithm**: Cosine similarity with chunk aggregation

## 📞 Support
If no results appear, check that:
- Your Google Drive folder is public
- The folder contains PDF files
- Your API key is valid and has Drive API access
        """, elem_classes=["markdown-content"])
    
    return demo

def main():
    """Main function to initialize and run the app"""
    
    logger.info("Starting CV Semantic Search application...")
    
    # Initialize database at startup
    if initialize_database():
        logger.info("✅ Database initialization successful")
    else:
        logger.error("❌ Database initialization failed")
    
    # Create and launch interface
    demo = create_interface()
    demo.launch(
        share=True,  # Enable sharing for Hugging Face Spaces
        server_name="0.0.0.0",  # Enable access from outside container
        server_port=7860,  # Standard port for Hugging Face Spaces
        show_error=True
    )

if __name__ == "__main__":
    main()