app.py

import os
import base64
import json
from flask import Flask, request, jsonify
from flask_cors import CORS
import spacy
from textblob import TextBlob
import re
import tempfile
import PyPDF2
import docx
import pyttsx3
import threading
import logging
from werkzeug.utils import secure_filename
from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline

# Configure logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

# Initialize Flask app
app = Flask(__name__)
CORS(app)  # Enable CORS for all routes

# Configure environment
UPLOAD_FOLDER = os.path.join(os.getcwd(), 'uploads')
if not os.path.exists(UPLOAD_FOLDER):
    os.makedirs(UPLOAD_FOLDER)
app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
app.config['MAX_CONTENT_LENGTH'] = 20 * 1024 * 1024  # 20MB max upload

# Set up Hugging Face model parameters
HF_MODEL = os.environ.get('HF_MODEL', "mistralai/Mistral-7B-Instruct-v0.2")
logger.info(f"Using Hugging Face model: {HF_MODEL}")

# Dictionary to store chat sessions
chat_sessions = {}

# Load spaCy model
try:
    nlp = spacy.load("en_core_web_sm")
    logger.info("Successfully loaded spaCy model")
except Exception as e:
    logger.error(f"Failed to load spaCy model: {str(e)}")
    # Fallback to a simpler model if available
    try:
        nlp = spacy.load("en_core_web_md")
        logger.info("Loaded fallback spaCy model")
    except:
        logger.error("Could not load any spaCy model")
        # Define empty nlp function as fallback
        def nlp(text):
            class MockDoc:
                def __init__(self, text):
                    self.text = text
                    self.noun_chunks = []
            return MockDoc(text)

# Initialize text-to-speech engine
try:
    engine = pyttsx3.init()
    logger.info("Text-to-speech engine initialized")
except Exception as e:
    logger.error(f"Failed to initialize text-to-speech: {str(e)}")
    engine = None

# Load Hugging Face model and tokenizer
def load_hf_model():
    try:
        logger.info(f"Loading model: {HF_MODEL}")
        tokenizer = AutoTokenizer.from_pretrained(HF_MODEL)
        model = AutoModelForCausalLM.from_pretrained(HF_MODEL)
        generator = pipeline("text-generation", model=model, tokenizer=tokenizer)
        logger.info("Successfully loaded model and tokenizer")
        return generator
    except Exception as e:
        logger.error(f"Error loading model: {str(e)}")
        return None

# Load model on startup
generator = load_hf_model()

# Bias detection patterns and empowering messages
bias_patterns = {
    "suitability for leadership": "Absolutely! Women have led globally—in government, business, and science.",
    "emotional stability": "Emotional intelligence is a leadership asset for everyone.",
    "tech ability": "Women are innovators in tech—from Ada Lovelace to today's pioneers.",
    "logical thinking": "Logic is a human ability, not gender-specific.",
    "career vs family": "Many women successfully balance career and family. Stereotypes don't define reality.",
    "aggressiveness in women": "Assertiveness is a leadership strength for all genders.",
    "women in STEM": "Women have been crucial in STEM fields, past and present.",
    "women in politics": "Women have led nations and made major political impacts globally.",
    "women's emotional nature": "Emotions are part of being human and a leadership strength.",
    "women's competence in business": "Women are highly competent business leaders and entrepreneurs.",
    "women's role in history": "Women have made monumental contributions across history."
}

# Suggestion for reframing biased questions
def suggest_reframing(pattern):
    reframes = {
        "suitability for leadership": "Ask about leadership qualities in all individuals.",
        "emotional stability": "Focus on emotional intelligence across all leaders.",
        "tech ability": "Highlight tech expertise without linking to gender.",
        "logical thinking": "Emphasize logical thinking as a universal human trait.",
        "career vs family": "Discuss career and family balance inclusively.",
        "aggressiveness in women": "Celebrate assertiveness for all genders.",
        "women in STEM": "Celebrate contributions of everyone in STEM.",
        "women in politics": "Recognize political leadership without assumptions.",
        "women's emotional nature": "Focus on emotional intelligence as a human strength.",
        "women's competence in business": "Highlight business leadership across all people.",
        "women's role in history": "Explore contributions from all genders."
    }
    return reframes.get(pattern, "Consider rephrasing to be more inclusive.")

# Sentiment analysis
def analyze_sentiment(text):
    blob = TextBlob(text)
    polarity = blob.sentiment.polarity
    if polarity > 0.1:
        return "positive"
    elif polarity < -0.1:
        return "negative"
    else:
        return "neutral"

# Bias detection with suggestion
def detect_gender_bias(text):
    doc = nlp(text.lower())
    for chunk in doc.noun_chunks:
        if "women" in chunk.text:
            for pattern in bias_patterns:
                if re.search(r'\b' + r'\b|\b'.join(pattern.split()) + r'\b', text.lower()):
                    suggestion = suggest_reframing(pattern)
                    return (
                        f"{bias_patterns[pattern]}\n\n"
                        "🛠️ Suggestion: " + suggestion
                    )
    return None

# File handling functions
def extract_text_from_pdf(file_path):
    """Extract text from PDF files"""
    try:
        text = ""
        with open(file_path, 'rb') as file:
            pdf_reader = PyPDF2.PdfReader(file)
            for page_num in range(len(pdf_reader.pages)):
                text += pdf_reader.pages[page_num].extract_text()
        return text
    except Exception as e:
        logger.error(f"Error reading PDF: {str(e)}")
        return f"Error reading PDF: {str(e)}"

def extract_text_from_docx(file_path):
    """Extract text from DOCX files"""
    try:
        doc = docx.Document(file_path)
        text = "\n".join([paragraph.text for paragraph in doc.paragraphs])
        return text
    except Exception as e:
        logger.error(f"Error reading DOCX: {str(e)}")
        return f"Error reading DOCX: {str(e)}"

def process_file(file_path, file_type):
    """Process different file types and extract text"""
    if not os.path.exists(file_path):
        return f"File not found: {file_path}"
    
    file_extension = file_type.lower()
    
    if 'pdf' in file_extension:
        return extract_text_from_pdf(file_path)
    elif file_extension in ['doc', 'docx']:
        return extract_text_from_docx(file_path)
    elif file_extension in ['txt', 'text']:
        try:
            with open(file_path, 'r', encoding='utf-8') as file:
                return file.read()
        except Exception as e:
            logger.error(f"Error reading text file: {str(e)}")
            return f"Error reading text file: {str(e)}"
    elif file_extension in ['xls', 'xlsx']:
        # Return placeholder for Excel files - consider integrating pandas for actual processing
        return "Excel file detected. Specific content analysis currently limited."
    elif file_extension in ['jpg', 'jpeg', 'png']:
        # Placeholder for image files - consider adding OCR
        return "Image file detected. OCR processing would occur here."
    else:
        return f"Processing for {file_extension} files is not supported."

def save_base64_file(base64_string, filename, file_type):
    """Save a base64 encoded file to disk"""
    try:
        file_data = base64.b64decode(base64_string)
        file_path = os.path.join(app.config['UPLOAD_FOLDER'], secure_filename(filename))
        
        with open(file_path, 'wb') as f:
            f.write(file_data)
            
        return file_path
    except Exception as e:
        logger.error(f"Error saving file: {str(e)}")
        return None

def get_or_create_chat_session(session_id):
    """Create a new chat session or return an existing one"""
    if session_id not in chat_sessions:
        logger.info(f"Creating new chat session: {session_id}")
        
        # Initialize with session history
        chat_sessions[session_id] = {
            "history": [
                {
                    "role": "user",
                    "content": "You are Ashabot, an ethical AI chatbot. Always respond respectfully and avoid engaging in gender-biased or discriminatory content. "
                                "If such content is detected, respond with educational, inclusive, and fact-based replies. "
                                "You can understand document content and respond to various file types including PDFs, documents, and images."
                },
                {
                    "role": "assistant",
                    "content": "I am Ashabot, an ethical AI chatbot. I'm here to assist you with information and responses that are respectful and inclusive. "
                                "I can help analyze document content and respond to various file types. How can I assist you today?"
                }
            ]
        }
    
    return chat_sessions[session_id]

def generate_suggestions(response_text):
    """Generate follow-up suggestions based on the response"""
    suggestions = []
    
    # Simple heuristic for generating follow-up questions
    if "leadership" in response_text.lower():
        suggestions.append("Tell me more about leadership qualities")
    
    if "STEM" in response_text or "science" in response_text.lower():
        suggestions.append("How can we encourage more diversity in STEM?")
        
    if "career" in response_text.lower():
        suggestions.append("What career opportunities align with my skills?")
    
    # Add generic suggestions if we don't have specific ones
    if len(suggestions) < 2:
        suggestions.extend([
            "How can I learn more about this topic?",
            "Could you provide some resources on this subject?"
        ])
    
    return suggestions[:2]  # Return at most 2 suggestions

def generate_opportunities(text, opportunities_data=None):
    """Generate potential opportunities based on user input and profile data"""
    opportunities = []
    
    if opportunities_data:
        skills = opportunities_data.get('skills', [])
        interests = opportunities_data.get('interests', [])
        
        # Simple matching algorithm - in production this would be more sophisticated
        if any(skill.lower() in text.lower() for skill in skills):
            opportunities.append({
                "title": "Skill Development Opportunity",
                "description": "Based on your skills, consider enhancing your expertise in this area.",
                "url": "https://example.com/skill-development"
            })
            
        if any(interest.lower() in text.lower() for interest in interests):
            opportunities.append({
                "title": "Interest-Based Opportunity",
                "description": "This aligns with your interests. Explore more in this field.",
                "url": "https://example.com/explore-interests"
            })
    
    # Add a generic opportunity if we don't have specific matches
    if not opportunities:
        opportunities.append({
            "title": "Learning Resource",
            "description": "Explore more about this topic through our learning platform",
            "url": "https://example.com/learn-more"
        })
    
    return opportunities

def generate_response_with_hf(prompt, chat_history=None):
    """Generate response using Hugging Face model"""
    if generator is None:
        return "Model not available. Please check server logs."
    
    try:
        # Prepare conversation history for the model
        formatted_prompt = ""
        if chat_history:
            for message in chat_history:
                role = message.get("role", "")
                content = message.get("content", "")
                if role == "user":
                    formatted_prompt += f"User: {content}\n"
                elif role == "assistant":
                    formatted_prompt += f"Assistant: {content}\n"
        
        # Add current prompt
        formatted_prompt += f"User: {prompt}\nAssistant:"
        
        # Generate response
        response = generator(
            formatted_prompt,
            max_length=1024,
            num_return_sequences=1,
            temperature=0.7,
            top_p=0.9,
            do_sample=True
        )
        
        # Extract and clean the response
        generated_text = response[0]['generated_text']
        assistant_response = generated_text.split("Assistant:")[-1].strip()
        
        # Handle potential empty responses
        if not assistant_response:
            assistant_response = "I apologize, but I couldn't generate a response. Please try rephrasing your question."
        
        return assistant_response
    
    except Exception as e:
        logger.error(f"Error generating response: {str(e)}")
        return f"An error occurred while generating a response: {str(e)}"

@app.route('/api/chat', methods=['POST'])
def chat():
    """Main endpoint for chat functionality"""
    try:
        # Parse request data
        data = request.json
        session_id = data.get('session_id')
        user_message = data.get('message', '')
        has_files = data.get('has_files', False)
        files = data.get('files', [])
        opportunities_data = data.get('opportunities_data', {})
        
        if not session_id:
            return jsonify({'error': 'Session ID is required'}), 400
        
        logger.info(f"Received request for session {session_id}, has_files: {has_files}")
        
        # Get chat session
        chat_session = get_or_create_chat_session(session_id)
        
        # Analyze sentiment
        sentiment = analyze_sentiment(user_message)
        logger.info(f"Message sentiment: {sentiment}")
        
        # Check for gender bias
        bias_warning = detect_gender_bias(user_message)
        if bias_warning:
            logger.info("Gender bias detected")
            response_text = f"I noticed some gender bias in your message. {bias_warning}\n\nLet's continue the conversation inclusively! 🌟"
            
            # Add messages to history
            chat_session["history"].append({"role": "user", "content": user_message})
            chat_session["history"].append({"role": "assistant", "content": response_text})
            
            return jsonify({
                'response': response_text,
                'suggestions': generate_suggestions(response_text),
                'opportunities': []
            })
        
        # Process files if present
        file_contents = []
        if has_files and files:
            for file_info in files:
                file_name = file_info.get('file_name')
                file_data = file_info.get('file_data')
                file_type = file_info.get('file_type')
                
                if file_name and file_data:
                    # Save file to disk
                    file_path = save_base64_file(file_data, file_name, file_type)
                    
                    if file_path:
                        # Process file based on type
                        file_content = process_file(file_path, file_type)
                        if not file_content.startswith("Error") and not file_content.startswith("Processing for"):
                            file_contents.append(f"Content from {file_name}: {file_content[:5000]}")  # Limit to 5000 chars per file
                            
                            # Add message about successfully processed file
                            logger.info(f"Successfully processed file: {file_name}")
                        else:
                            logger.warning(f"Issue processing file: {file_content}")
                    else:
                        logger.error(f"Failed to save file: {file_name}")
        
        # Construct complete message with both user text and file contents
        complete_message = user_message
        if file_contents:
            complete_message += "\n\nAttached files content:\n" + "\n\n".join(file_contents)
        
        # Add user message to history
        chat_session["history"].append({"role": "user", "content": complete_message})
        
        # Generate response with HF model
        try:
            response_text = generate_response_with_hf(complete_message, chat_session["history"])
            
            # Add assistant response to history
            chat_session["history"].append({"role": "assistant", "content": response_text})
            
            # Keep history at a reasonable size (last 10 messages)
            if len(chat_session["history"]) > 12:  # Initial system messages + 10 user/assistant exchanges
                chat_session["history"] = chat_session["history"][:2] + chat_session["history"][-10:]
            
            # Generate suggestions based on response
            suggestions = generate_suggestions(response_text)
            
            # Generate opportunities based on user message and profile
            opportunities = generate_opportunities(complete_message, opportunities_data)
            
            return jsonify({
                'response': response_text,
                'suggestions': suggestions,
                'opportunities': opportunities
            })
            
        except Exception as e:
            logger.error(f"Error generating response: {str(e)}")
            return jsonify({
                'error': f"Error generating response: {str(e)}",
                'suggestions': ["Could you try rephrasing your question?", "Let's try a different topic"],
                'opportunities': []
            }), 500
                
    except Exception as e:
        logger.error(f"Error processing request: {str(e)}")
        return jsonify({'error': str(e)}), 500

@app.route('/api/health', methods=['GET'])
def health_check():
    """Health check endpoint"""
    return jsonify({
        'status': 'ok', 
        'service': 'Ashabot API',
        'model': HF_MODEL
    })

@app.route('/', methods=['GET'])
def index():
    """Root endpoint with API documentation"""
    return jsonify({
        'service': 'Ashabot API',
        'version': '1.0.0',
        'model': HF_MODEL,
        'endpoints': {
            '/api/chat': 'POST - Send messages and files for processing',
            '/api/health': 'GET - Health check'
        },
        'documentation': 'See README.md for full API documentation'
    })

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port, debug=False)  # Set debug=False for production