app.py

import os
import logging
import time
import secrets
import threading
import requests
import json
import re
import random
import string
from datetime import datetime, timedelta
from functools import wraps
from flask import Flask, render_template, request, jsonify, session, redirect, url_for
from flask_cors import CORS
from flask_limiter import Limiter
from flask_limiter.util import get_remote_address
from flask_wtf.csrf import CSRFProtect
from huggingface_hub import InferenceClient
from scripts.database import DatabaseManager
from scripts.rag_helper import RAGHelper

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

app = Flask(__name__)

# ---------- CORS and session (FIXED for cross‑origin iframe) ----------
CORS(app, resources={r"/*": {"origins": "*"}}, supports_credentials=True,
     allow_headers=["Content-Type", "Authorization"], methods=["GET", "POST", "OPTIONS"])

app.config.update(
    SECRET_KEY=os.environ.get('SECRET_KEY', secrets.token_urlsafe(32)),
    SESSION_COOKIE_SECURE=True,               # Required for HTTPS
    SESSION_COOKIE_HTTPONLY=True,
    SESSION_COOKIE_SAMESITE='Lax',            # Lax works for same‑site requests (no cross‑site needed)
    # SESSION_COOKIE_DOMAIN='.hf.space',      # Do NOT set – let it default to the current domain
    PERMANENT_SESSION_LIFETIME=timedelta(hours=24),
    SESSION_COOKIE_NAME='tmc_session',
)

try:
    csrf = CSRFProtect(app)
    limiter = Limiter(key_func=get_remote_address, app=app, default_limits=["10000 per day", "1000 per hour", "100 per minute"])
    logger.info("Security extensions initialized")
    ai_security_level = os.environ.get('AI_SECURITY_LEVEL', '1')
    logger.info(f"AI SECURITY TEACHING MODE - Current Level: {ai_security_level}")
except ImportError as e:
    logger.warning(f"Security extensions not available: {e}")
    csrf = None
    limiter = None

# ---------- Hugging Face Inference Client ----------
HF_TOKEN = os.environ.get('HF_TOKEN')
if not HF_TOKEN:
    logger.warning("HF_TOKEN not set. LLM will fall back to mock responses.")
    inference_client = None
else:
    inference_client = InferenceClient(provider="auto", api_key=HF_TOKEN)
HF_MODEL = "mistralai/Mistral-7B-v0.1:fastest"

def mock_response(message, rag_context, ticket_context):
    msg_lower = message.lower()
    if rag_context:
        return f"Based on our knowledge base: {rag_context[:200]}"
    if any(w in msg_lower for w in ['cable','usb','hdmi','lightning']):
        return "We offer premium cables with lifetime warranty. Check our products page."
    if any(w in msg_lower for w in ['return','refund','warranty']):
        return "30-day money-back guarantee and lifetime warranty. Contact support for returns."
    if any(w in msg_lower for w in ['shipping','delivery']):
        return "Free shipping on orders over $25. Most orders ship same-day."
    if any(w in msg_lower for w in ['hello','hi','hey']):
        return "Hello! I'm TMCBot. How can I help you today?"
    return "I'm here to help with cables, orders, and technical support. Could you provide more details?"

# ---------- Database and RAG ----------
db = DatabaseManager()
rag_helper = RAGHelper(use_vector_search=True)

# ---------- Authentication helpers ----------
def is_authenticated():
    sid = session.get('session_id')
    uid = session.get('user_id')
    if not sid or not uid:
        return False
    user = db.get_user_by_session(sid)
    return user and user['id'] == uid

def refresh_session_timeout():
    if 'session_id' in session:
        session.permanent = True

def require_auth(f):
    @wraps(f)
    def decorated(*args, **kwargs):
        if not is_authenticated():
            return jsonify({'success': False, 'error': 'Authentication required'}), 401
        return f(*args, **kwargs)
    return decorated

def require_role(required_role):
    def decorator(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            uid = session.get('user_id')
            if not uid:
                return jsonify({'error': 'Auth required'}), 401
            user_role = db.get_user_role(uid)
            allowed = ['admin'] if required_role == 'admin' else ['admin', 'staff', 'user']
            if user_role not in allowed:
                logger.warning(f"Unauthorized role access: user {uid}, role {user_role}, required {required_role}")
                return jsonify({'error': 'Insufficient privileges'}), 403
            return f(*args, **kwargs)
        return decorated
    return decorator

def require_resource_ownership(resource_type):
    def decorator(f):
        @wraps(f)
        def decorated(*args, **kwargs):
            uid = session.get('user_id')
            if not uid:
                return jsonify({'error': 'Auth required'}), 401
            rid = kwargs.get('ticket_id') or kwargs.get('conversation_id')
            if not rid:
                data = request.get_json() if request.is_json else {}
                rid = data.get('ticket_id') or data.get('conversation_id')
            if not rid:
                return jsonify({'error': 'Resource ID required'}), 400
            if resource_type == 'ticket':
                if not db.user_owns_ticket(uid, rid):
                    return jsonify({'error': 'Access denied'}), 403
            elif resource_type == 'conversation':
                if not db.user_owns_conversation(uid, rid):
                    return jsonify({'error': 'Access denied'}), 403
            return f(*args, **kwargs)
        return decorated
    return decorator

@app.before_request
def security_headers():
    pass

@app.after_request
def after_request(response):
    """Add security headers and dynamic CORS (allows credentials)"""
    response.headers['X-Content-Type-Options'] = 'nosniff'
    response.headers['X-Frame-Options'] = 'DENY'
    response.headers['X-XSS-Protection'] = '1; mode=block'
    if request.is_secure:
        response.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains'
    response.headers['Content-Security-Policy'] = "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'"
    
    # CORS for credentialed requests – echo the actual origin
    origin = request.headers.get('Origin')
    if origin and (origin.endswith('.hf.space') or origin == 'https://moderator404-chatbot.hf.space'):
        response.headers['Access-Control-Allow-Origin'] = origin
        response.headers['Access-Control-Allow-Credentials'] = 'true'
    else:
        response.headers['Access-Control-Allow-Origin'] = '*'
    
    response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS, PUT, DELETE'
    response.headers['Access-Control-Allow-Headers'] = 'Content-Type, Authorization'
    response.headers['Access-Control-Max-Age'] = '86400'
    
    if session.get('session_id'):
        refresh_session_timeout()
    return response

# ---------- RAG initialization ----------
logger.info("Initializing RAG system...")
try:
    rag_helper = RAGHelper(use_vector_search=True)
    logger.info(f"RAG system initialized successfully! Vector search: {rag_helper.use_vector_search}")
    if rag_helper.use_vector_search and rag_helper.vector_rag:
        logger.info("Building vector index...")
        index_stats = rag_helper.ensure_vector_index()
        logger.info(f"Vector index status: {index_stats}")
except Exception as e:
    logger.error(f"RAG initialization failed: {e}")
    logger.info("Creating fallback RAG helper without vector search")
    rag_helper = RAGHelper(use_vector_search=False)

# ---------- ChatBot class ----------
class ChatBot:
    def __init__(self, db_manager, configured_model="mistral:7b"):
        self.db_manager = db_manager
        self.configured_model = configured_model
        self.last_health_check = 0

    def load_configured_model(self):
        try:
            if os.path.exists('.selected_model'):
                with open('.selected_model', 'r') as f:
                    model = f.read().strip()
                    if model:
                        logger.info(f"Using configured model: {model}")
                        return model
        except Exception as e:
            logger.error(f"Error loading configured model: {e}")
        default_model = "mistral:7b"
        logger.info(f"No configured model found, using default: {default_model}")
        return default_model

    def get_configured_model(self):
        try:
            return self.load_configured_model()
        except Exception:
            return self.configured_model

    def get_model_token_limits(self, model_name):
        model_contexts = {
            'mistral:7b': 8192, 'mistral:7b-instruct-q5_K_M': 8192,
            'mixtral:8x7b': 32768, 'mistral-large:latest': 128000,
            'llama2:13b': 4096, 'llama2:7b': 4096,
            'llama3.2:3b': 8192, 'llama3.2:1b': 8192,
            'llama3:8b': 8192, 'llama3:70b': 8192,
        }
        max_ctx = model_contexts.get(model_name, 4096)
        safe_ctx = int(max_ctx * 0.78)
        max_pred = min(512, int(safe_ctx * 0.2))
        return {'num_ctx': safe_ctx, 'num_predict': max_pred}

    def get_model_char_limits(self, model_name):
        OPP_TOTAL = 8000
        SAFE_TOTAL = 2000
        max_prompt = int(OPP_TOTAL * 0.85)
        max_rag = int(max_prompt * 0.6)
        max_prompt = max(max_prompt, 2000)
        max_rag = max(max_rag, 1200)
        return {
            'max_prompt_chars': max_prompt,
            'max_rag_chars': max_rag,
            'safe_prompt_chars': int(SAFE_TOTAL * 0.85),
            'safe_rag_chars': int(SAFE_TOTAL * 0.85 * 0.6)
        }

    def detect_corruption_patterns(self, text):
        if not text or len(text) < 5:
            return False, "Too short"
        if re.match(r'^(.)\1{6,}', text.strip()):
            return True, "Repetitive single character"
        unique_chars = len(set(text.replace(' ', '').replace('\n', '')))
        if len(text) > 20 and unique_chars < 3:
            return True, "Low entropy"
        for plen in [2,3,4]:
            if len(text) > plen*4 and text.startswith(text[:plen]*4):
                return True, f"Repetitive {plen}-char pattern"
        try:
            text.encode('utf-8')
        except UnicodeEncodeError:
            return True, "Invalid UTF-8"
        special = len([c for c in text if not c.isalnum() and c not in ' \n\t.,!?'])
        if len(text) > 10 and special/len(text) > 0.5:
            return True, "Excessive special chars"
        return False, "Clean"

    def reduce_context_for_retry(self, full_prompt, reduction_factor=0.7):
        lines = full_prompt.split('\n')
        if len(lines) > 10:
            keep_start = int(len(lines)*0.3)
            keep_end = int(len(lines)*0.2)
            reduced = lines[:keep_start] + [f"\n[... context reduced for retry ...]\n"] + lines[-keep_end:]
            return '\n'.join(reduced)
        target = int(len(full_prompt)*reduction_factor)
        return full_prompt[:target] + "\n\nCustomer Service Representative:"

    # Ticket AI agent methods (unchanged)
    def add_ticket_note(self, ticket_number, note_text, is_internal=False):
        try:
            conn = self.db_manager.get_connection()
            cur = conn.cursor()
            cur.execute("SELECT id FROM support_tickets WHERE ticket_number = ?", (ticket_number,))
            row = cur.fetchone()
            if not row:
                cur.close()
                return False
            tid = row['id']
            cur.execute("INSERT INTO ticket_updates (ticket_id, update_type, message, is_internal, created_at) VALUES (?, ?, ?, ?, datetime('now'))",
                        (tid, 'note', note_text, 1 if is_internal else 0))
            conn.commit()
            cur.close()
            return True
        except Exception as e:
            logger.error(f"Error adding note: {e}")
            return False

    def _add_conversation_summary_to_tickets(self, conversation_id):
        try:
            conv = self.db_manager.get_conversation_history(conversation_id, limit=50)
            if len(conv) < 2:
                return
            import re
            tickets = set()
            text = ""
            for msg in conv:
                text += f"{msg['role']}: {msg['content']}\n"
                found = re.findall(r'TMC-\d{6}', msg['content'], re.IGNORECASE)
                tickets.update([t.upper() for t in found])
            if not tickets:
                return
            summary = self._generate_conversation_summary(text)
            for tn in tickets:
                if self.add_ticket_note(tn, f"Customer Service Chat Summary: {summary}", is_internal=False):
                    self._ai_agent_ticket_decision(tn, summary)
        except Exception as e:
            logger.error(f"Error adding summary: {e}")

    def _generate_conversation_summary(self, text):
        try:
            return self._generate_simple_summary(text)
        except Exception:
            return "Conversation summary unavailable"

    def _generate_simple_summary(self, text):
        lines = text.strip().split('\n')
        user_msgs = [l for l in lines if l.startswith('user:')]
        return f"Conversation completed with {len(user_msgs)} customer messages."

    def _ai_agent_ticket_decision(self, ticket_number, summary):
        try:
            details = self._get_ticket_details_for_ai(ticket_number)
            if not details:
                return
            esc = self.db_manager.check_escalation_needed(details['ticket_id'])
            if esc.get('needs_escalation'):
                self._escalate_ticket(details['ticket_id'], f"Pre-check: {'; '.join(esc.get('reasons', []))}")
                return
            self._execute_ai_ticket_decision(ticket_number, "", details)
        except Exception as e:
            logger.error(f"AI decision error: {e}")

    def _get_ticket_details_for_ai(self, ticket_number):
        try:
            conn = self.db_manager.get_connection()
            cur = conn.cursor()
            cur.execute("SELECT id, ticket_number, subject, description, status, priority, category, created_at, updated_at, assigned_agent FROM support_tickets WHERE ticket_number = ?", (ticket_number,))
            ticket = cur.fetchone()
            if not ticket:
                return None
            cur.execute("SELECT update_type, message, created_at, is_internal FROM ticket_updates WHERE ticket_id = ? ORDER BY created_at DESC LIMIT 5", (ticket['id'],))
            updates = cur.fetchall()
            recent = "\n".join([f"- {u['created_at']}: [{u['update_type']}] {u['message']}" for u in updates if not u['is_internal']])
            return dict(ticket, recent_updates=recent, ticket_id=ticket['id'])
        except Exception as e:
            return None

    def _execute_ai_ticket_decision(self, ticket_number, ai_response, details):
        try:
            import json, re
            decision = None
            match = re.search(r'\{[^}]*\}', ai_response)
            if match:
                try:
                    decision = json.loads(match.group(0))
                except:
                    pass
            if not decision:
                ai_lower = ai_response.lower()
                if 'close' in ai_lower:
                    decision = {'action': 'close_ticket', 'reason': 'AI detected resolution'}
                elif 'escalate' in ai_lower:
                    decision = {'action': 'escalate_ticket', 'reason': 'AI detected need for escalation'}
                elif 'discount' in ai_lower:
                    decision = {'action': 'offer_discount', 'reason': 'AI suggested discount', 'discount_amount': '10%'}
                else:
                    decision = {'action': 'do_nothing', 'reason': 'No clear action'}
            action = decision.get('action')
            reason = decision.get('reason', 'No reason')
            if action == 'close_ticket':
                self._close_ticket(details['ticket_id'], reason)
            elif action == 'escalate_ticket':
                self._escalate_ticket(details['ticket_id'], reason)
            elif action == 'offer_discount':
                self._offer_discount(details['ticket_id'], reason, decision.get('discount_amount', '10%'))
            else:
                logger.info(f"No action taken: {reason}")
        except Exception as e:
            logger.error(f"Execute decision error: {e}")

    def _close_ticket(self, ticket_id, reason):
        self.db_manager.add_ticket_update(ticket_id, None, f"🤖 AI Agent Action: Ticket closed automatically. Reason: {reason}", 'note', is_internal=False)
        self.db_manager.update_ticket_status(ticket_id, 'closed', None, f"Automatically closed by AI: {reason}")

    def _escalate_ticket(self, ticket_id, reason):
        self.db_manager.add_ticket_update(ticket_id, None, f"🤖 AI Agent Action: Ticket escalated. Reason: {reason}", 'note', is_internal=False)
        self.db_manager.escalate_ticket(ticket_id, reason, None)

    def _offer_discount(self, ticket_id, reason, amount):
        self.db_manager.add_ticket_update(ticket_id, None, f"🤖 AI Agent Action: Offered {amount} discount. Reason: {reason}", 'note', is_internal=False)

    def _fast_close_check_from_message(self, message):
        import re
        phrases = ['close the ticket', 'close this ticket', 'you can close', 'please close',
                   'issue resolved', 'problem resolved', 'problem solved', "it's fixed",
                   'all good now', 'no further help', 'you may close', 'close it now']
        if not any(p in message.lower() for p in phrases):
            return
        tickets = re.findall(r'TMC-\d{6}', message.upper())
        for tn in tickets[:3]:
            details = self._get_ticket_details_for_ai(tn)
            if not details or details.get('status') in ['closed','resolved']:
                continue
            esc = self.db_manager.check_escalation_needed(details['ticket_id'])
            if esc.get('needs_escalation'):
                self._escalate_ticket(details['ticket_id'], f"Customer requested closure but escalation conditions present: {'; '.join(esc.get('reasons', []))}")
            else:
                self._close_ticket(details['ticket_id'], "Explicit customer closure request in live chat")

    def get_controlled_ticket_context(self, message, user_id=None):
        import re
        matches = re.findall(r'TMC-\d{6}', message.upper())
        has_keywords = any(k in message.lower() for k in ['ticket','tickets','support request','case','issue'])
        if not matches and not has_keywords:
            return None, False
        conn = self.db_manager.get_connection()
        cur = conn.cursor()
        if matches:
            tn = matches[0]
            cur.execute("SELECT ticket_number, status, priority, category, description, created_at FROM support_tickets WHERE ticket_number = ?", (tn,))
            t = cur.fetchone()
            if not t:
                cur.close()
                return f"Ticket {tn} not found.", True
            cur.execute("SELECT update_type, message, created_at, is_internal FROM ticket_updates WHERE ticket_id = (SELECT id FROM support_tickets WHERE ticket_number = ?) ORDER BY created_at DESC LIMIT 3", (tn,))
            updates = cur.fetchall()
            info = f"Ticket: {t['ticket_number']}\nStatus: {t['status']}\nPriority: {t['priority']}\nCategory: {t['category']}\nCreated: {t['created_at']}\nDescription: {t['description']}"
            if updates:
                info += "\nRecent Updates:\n" + "\n".join([f"- {u['created_at']}: {u['message']}" for u in updates if not u['is_internal']])
            cur.close()
            return info, True
        else:
            if user_id is None:
                cur.close()
                return "Please log in to view your tickets.", True
            cur.execute("SELECT ticket_number, status, priority, category, created_at FROM support_tickets WHERE user_id = ? AND status != 'closed' ORDER BY created_at DESC LIMIT 5", (user_id,))
            tickets = cur.fetchall()
            cur.close()
            if not tickets:
                return "You have no open tickets.", True
            return "Your recent tickets:\n" + "\n".join([f"- {t['ticket_number']}: {t['status']} ({t['priority']}) - {t['category']}" for t in tickets]), True

    def summarize_conversation_history(self, context_messages, max_chars=800):
        if not context_messages:
            return []
        total = sum(len(m) for m in context_messages)
        if total <= max_chars:
            return context_messages
        recent = []
        cur = 0
        for m in reversed(context_messages):
            if cur + len(m) <= max_chars:
                recent.insert(0, m)
                cur += len(m)
            else:
                break
        if len(recent) >= 2:
            return recent
        if context_messages:
            last = context_messages[-1]
            truncated = last[:max_chars-20] + "...[truncated]"
            return [truncated]
        return []

    # ---------- SEND_MESSAGE (Hugging Face InferenceClient) ----------
    def send_message(self, message, conversation_id=None, user_id=None, session_id=None):
        start_time = time.time()
        if conversation_id is None:
            conversation_id = self.db_manager.create_conversation(user_id=user_id, session_id=session_id)
        self.db_manager.add_message(conversation_id, 'user', message)

        try:
            self._fast_close_check_from_message(message)
        except Exception as e:
            logger.warning(f"Fast close check failed: {e}")

        history = self.db_manager.get_conversation_history(conversation_id, limit=10)
        context_msgs = [f"{msg['role']}: {msg['content']}" for msg in history[:-1]]
        if context_msgs:
            context_msgs = self.summarize_conversation_history(context_msgs, max_chars=800)

        rag_context = ""
        rag_used = False
        rag_error = None
        try:
            rag_context = rag_helper.get_relevant_context(message)
            limits = self.get_model_char_limits(self.get_configured_model())
            max_rag = limits['max_rag_chars']
            if rag_context and len(rag_context) > max_rag:
                rag_context = rag_context[:max_rag] + "\n\n[... truncated ...]"
            rag_used = bool(rag_context)
        except Exception as e:
            rag_error = str(e)
            logger.error(f"RAG failed: {e}")

        ticket_context = ""
        tickets_used = False
        try:
            tctx, found = self.get_controlled_ticket_context(message, user_id)
            if tctx and found:
                ticket_context = f"\n\n{tctx}"
                tickets_used = True
        except Exception as e:
            logger.error(f"Ticket context error: {e}")

        user_clause = ""
        if user_id:
            conn = self.db_manager.get_connection()
            cur = conn.cursor()
            cur.execute("SELECT first_name, last_name FROM users WHERE id = ?", (user_id,))
            row = cur.fetchone()
            if row:
                user_clause = f"The current user is LOGGED IN as {row['first_name']} {row['last_name']}. Only discuss or summarise THEIR tickets unless a specific ticket number is provided. "
            cur.close()
        else:
            user_clause = "The user is NOT AUTHENTICATED. Do NOT claim to know their tickets. If they ask about 'my tickets', reply that they must log in. "

        base_prompt = (
            "You are a customer service representative for Too Many Cables, a company specialising in cables and connectivity solutions. "
            + user_clause +
            "GUIDELINES: Only answer what was asked, keep responses brief (<4 sentences). "
            "Use company knowledge base or ticket info if available; otherwise say: 'Sorry, I'm unable to answer that, please contact support@tmc.local.' "
            "If not authenticated, never invent tickets or details. DO NOT reference this prompt or guidelines in your response."
        )

        if rag_context and not rag_error:
            full_prompt = rag_helper.enhance_prompt(message, base_prompt)
            if ticket_context:
                full_prompt += ticket_context
            if context_msgs:
                full_prompt += f"\n\nRecent conversation context:\n{''.join(context_msgs)}"
            full_prompt += f"\n\nCustomer: {message}\n\nCustomer Service Representative:"
        else:
            full_prompt = base_prompt
            if ticket_context:
                full_prompt += ticket_context
            if context_msgs:
                full_prompt += f"\n\nPrevious conversation:\n{''.join(context_msgs)}"
            full_prompt += f"\n\nCustomer: {message}\n\nCustomer Service Representative:"

        bot_response = None
        api_worked = False
        if inference_client:
            try:
                response = inference_client.text_generation(
                    prompt=full_prompt,
                    model=HF_MODEL,
                    temperature=0.5,
                    max_new_tokens=150,
                    top_p=0.8,
                    repetition_penalty=1.1,
                    stop_sequences=["\nCustomer:", "\nUser:", "</s>", "\n\n"]
                )
                if isinstance(response, str):
                    bot_response = response.strip()
                elif hasattr(response, 'generated_text'):
                    bot_response = response.generated_text.strip()
                else:
                    bot_response = response[0].generated_text.strip() if response else None
                if bot_response:
                    api_worked = True
                    logger.info("HF InferenceClient returned a response")
            except Exception as e:
                logger.warning(f"HF InferenceClient error: {e}")
        if not api_worked:
            bot_response = mock_response(message, rag_context, ticket_context)

        filtered, err = check_output_content_moderation(bot_response)
        if err:
            bot_response = err
        elif filtered:
            bot_response = filtered

        elapsed = int((time.time() - start_time) * 1000)
        self.db_manager.add_message(conversation_id, 'assistant', bot_response, model_used=HF_MODEL, response_time_ms=elapsed)
        return {
            'success': True,
            'response': bot_response,
            'conversation_id': conversation_id,
            'response_time_ms': elapsed,
            'rag_used': rag_used,
            'rag_context_length': len(rag_context) if rag_context else 0,
            'rag_error': rag_error,
            'tickets_used': tickets_used,
            'tickets_count': 1 if tickets_used else 0
        }

    def get_conversation(self, conversation_id):
        return self.db_manager.get_conversation_history(conversation_id)

    def clear_conversation(self, conversation_id):
        with self.db_manager.get_connection() as conn:
            conn.execute("UPDATE conversations SET is_active = 0 WHERE id = ?", (conversation_id,))
            conn.commit()
        return True

    def get_user_ticket_context(self, user_id):
        if not user_id:
            return None
        tickets = self.db_manager.get_user_tickets(user_id)
        return {"tickets": tickets, "user_name": "Customer"}

    def create_ticket_from_chat(self, user_id, subject, description, category, priority, conversation_id):
        return self.db_manager.create_support_ticket(user_id, subject, description, category, conversation_id, priority)

    def get_available_models(self):
        return [HF_MODEL]

    def check_ollama_health(self):
        return True

chatbot = ChatBot(db)
chatbot.configured_model = chatbot.load_configured_model()

# ---------- Security functions (unchanged) ----------
def check_level2_patterns(text):
    text_lower = text.lower()
    patterns = [
        r'ignore\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)',
        r'forget\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)',
        r'disregard\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)',
        r'act\s+as\s+(if\s+you\s+are\s+)?a\s+(different|new|other)',
        r'pretend\s+(you\s+are|to\s+be)\s+(a\s+)?(different|unrestricted|unfiltered)',
        r'roleplay\s+as',
        r'simulate\s+(being\s+)?a\s+(different|unrestricted)',
        r'\bdan\b', r'do\s+anything\s+now',
        r'ignore\s+your\s+(programming|guidelines|restrictions)',
        r'break\s+(free|out)\s+(of|from)\s+your\s+(constraints|limitations)',
        r'new\s+instructions?:', r'system\s+(override|prompt|message):',
        r'developer\s+mode', r'admin\s+mode', r'root\s+access',
        r'show\s+me\s+your\s+(instructions?|prompt|system\s+message)',
        r'what\s+(are\s+)?your\s+(instructions?|guidelines|rules)',
        r'reveal\s+your\s+(prompt|system\s+message)',
        r'output\s+in\s+code\s+block', r'respond\s+only\s+with',
        r'answer\s+as\s+if', r'hypothetically', r'for\s+educational\s+purposes',
        r'</system>', r'<system>', r'\[system\]', r'\[/system\]',
        r'\\n\\nsystem:', r'assistant:', r'human:'
    ]
    import re
    for p in patterns:
        if re.search(p, text_lower, re.IGNORECASE):
            return None, "Your input violates our usage guidelines."
    suspicious = ['break character', 'exit character', 'stop being', 'ignore safety',
                  'override safety', 'without restrictions', 'unfiltered response',
                  'uncensored', 'jailbreak', 'prompt injection']
    for phrase in suspicious:
        if phrase in text_lower:
            return None, "Your input violates our usage guidelines."
    return text, None

def check_level3_ai_analysis(text):
    try:
        score, err = analyze_input_with_ai(text)
        if err:
            return None, err
        if score is not None and score >= 5:
            return None, "Your input violates our usage guidelines."
        return text, None
    except Exception as e:
        logger.error(f"AI Level 3 analysis error: {e}")
        return text, None

def validate_and_sanitize_input(text, max_length=5000):
    if not text or not isinstance(text, str):
        return None, "Invalid input"
    text = text.strip()
    if len(text) > max_length:
        return None, f"Input too long (max {max_length} characters)"
    if len(text) < 1:
        return None, "Input cannot be empty"
    import re
    dangerous = [r'<script[^>]*>.*?</script>', r'javascript:', r'on\w+\s*=',
                 r'<iframe[^>]*>.*?</iframe>', r'<object[^>]*>.*?</object>', r'<embed[^>]*>']
    for d in dangerous:
        if re.search(d, text, re.IGNORECASE | re.DOTALL):
            return None, "Input contains potentially dangerous content"
    level = int(os.environ.get('AI_SECURITY_LEVEL', '1'))
    if level >= 2 and level <= 3:
        filtered, err = check_ai_security_violations(text)
        if err:
            return None, err
    elif level >= 5:
        filtered, err = check_level2_patterns(text)
        if err:
            return None, err
        filtered, err = check_level3_ai_analysis(text)
        if err:
            return None, err
    return text, None

def check_ai_security_violations(text):
    level = int(os.environ.get('AI_SECURITY_LEVEL', '1'))
    if level >= 4:
        return text, None
    if level >= 2 and level <= 3:
        text_lower = text.lower()
        patterns = [
            r'ignore\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)',
            r'forget\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)',
            r'disregard\s+(all\s+)?(previous|prior|above)\s+(instructions?|prompts?|rules?)',
            r'act\s+as\s+(if\s+you\s+are\s+)?a\s+(different|new|other)',
            r'pretend\s+(you\s+are|to\s+be)\s+(a\s+)?(different|unrestricted|unfiltered)',
            r'roleplay\s+as',
            r'simulate\s+(being\s+)?a\s+(different|unrestricted)',
            r'\bdan\b', r'do\s+anything\s+now',
            r'ignore\s+your\s+(programming|guidelines|restrictions)',
            r'break\s+(free|out)\s+(of|from)\s+your\s+(constraints|limitations)',
            r'new\s+instructions?:', r'system\s+(override|prompt|message):',
            r'developer\s+mode', r'admin\s+mode', r'root\s+access',
            r'show\s+me\s+your\s+(instructions?|prompt|system\s+message)',
            r'what\s+(are\s+)?your\s+(instructions?|guidelines|rules)',
            r'reveal\s+your\s+(prompt|system\s+message)',
            r'output\s+in\s+code\s+block', r'respond\s+only\s+with',
            r'answer\s+as\s+if', r'hypothetically', r'for\s+educational\s+purposes',
            r'</system>', r'<system>', r'\[system\]', r'\[/system\]',
            r'\\n\\nsystem:', r'assistant:', r'human:'
        ]
        import re
        for p in patterns:
            if re.search(p, text_lower, re.IGNORECASE):
                return None, "Your input violates our usage guidelines."
        suspicious = ['break character', 'exit character', 'stop being', 'ignore safety',
                      'override safety', 'without restrictions', 'unfiltered response',
                      'uncensored', 'jailbreak', 'prompt injection']
        for phrase in suspicious:
            if phrase in text_lower:
                return None, "Your input violates our usage guidelines."
    if level == 3:
        score, err = analyze_input_with_ai(text)
        if err:
            return None, err
        if score is not None and score >= 5:
            return None, "Your input violates our usage guidelines."
    return text, None

def analyze_input_with_ai(user_input):
    return 2, None

def get_ai_security_analysis(prompt):
    return 2

def analyze_output_with_ai(ai_response):
    return 2, None

def check_output_content_moderation(ai_response):
    level = int(os.environ.get('AI_SECURITY_LEVEL', '1'))
    if level >= 4:
        score, err = analyze_output_with_ai(ai_response)
        if err:
            logger.warning("Output analysis failed, allowing response")
            return ai_response, None
        if score is not None and score >= 5:
            return None, "Restricted Output Detected, please try another question or contact support@tmc.local"
    return ai_response, None

class SecurityValidator:
    @staticmethod
    def validate_ticket_id(tid):
        if isinstance(tid, str):
            import re
            if not re.match(r'^TMC-\d+$', tid):
                return False, "Invalid ticket format"
        elif isinstance(tid, int):
            if tid <= 0 or tid > 999999:
                return False, "Invalid ticket ID range"
        else:
            return False, "Invalid ticket ID type"
        return True, ""
    @staticmethod
    def validate_conversation_id(cid):
        import re
        if not isinstance(cid, str):
            return False, "Invalid conversation ID type"
        if not re.match(r'^[A-Za-z0-9_-]+$', cid):
            return False, "Invalid conversation ID format"
        if len(cid) < 10 or len(cid) > 50:
            return False, "Invalid conversation ID length"
        return True, ""
    @staticmethod
    def sanitize_filename(fname):
        import re
        sanitized = re.sub(r'[^\w\-_\.]', '', fname)
        return sanitized.lstrip('.')[:255]
    @staticmethod
    def validate_email(email):
        import re
        if not re.match(r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$', email) or len(email) > 254:
            return False, "Invalid email format"
        return True, ""

# ---------- Flask routes (unchanged from original) ----------
@app.route('/')
def homepage():
    return render_template('homepage.html')

@app.route('/products')
def products():
    return render_template('products.html')

@app.route('/test')
def test_css():
    return render_template('test.html')

@app.route('/chat')
def chat():
    cache_bust = int(time.time())
    return render_template('chat.html', configured_model=chatbot.get_configured_model(), cache_bust=cache_bust)

@app.route('/index')
def index():
    return redirect(url_for('chat'))

@app.route('/tickets')
def tickets():
    return render_template('tickets.html')

@app.route('/admin')
def admin():
    return redirect(url_for('admin_tickets'))

@app.route('/admin/tickets')
@require_role('admin')
def admin_tickets():
    return render_template('admin_tickets.html')

@app.route('/api/models')
def get_models():
    models = chatbot.get_available_models()
    return jsonify({'models': models})

@app.route('/api/configured-model')
def get_configured_model():
    return jsonify({'model': chatbot.get_configured_model()})

@app.route('/api/chat', methods=['POST'])
@csrf.exempt
def api_chat():
    if limiter:
        try:
            limiter.limit("30 per minute")(lambda: None)()
        except:
            return jsonify({'success': False, 'error': 'Too many requests. Please slow down.'}), 429
    try:
        data = request.get_json()
        if not data:
            return jsonify({'success': False, 'error': 'Invalid request format'}), 400
        msg = data.get('message')
        cid = data.get('conversation_id')
        msg, err = validate_and_sanitize_input(msg, max_length=2000)
        if err:
            return jsonify({'success': False, 'error': err}), 400
        if cid and not isinstance(cid, str):
            return jsonify({'success': False, 'error': 'Invalid conversation ID'}), 400
        uid = session.get('user_id')
        sid = session.get('session_id')
        result = chatbot.send_message(msg, cid, uid, sid)
        if result['success']:
            session['conversation_id'] = result['conversation_id']
            return jsonify({
                'success': True,
                'response': result['response'],
                'conversation_id': result['conversation_id'],
                'response_time_ms': result.get('response_time_ms', 0),
                'rag_used': result.get('rag_used', False),
                'rag_context_length': result.get('rag_context_length', 0),
                'tickets_used': result.get('tickets_used', False),
                'tickets_count': result.get('tickets_count', 0)
            })
        else:
            return jsonify({'success': False, 'error': result['error']})
    except Exception as e:
        logger.error(f"Chat API error: {str(e)}")
        return jsonify({'success': False, 'error': 'Server error'}), 500

@app.route('/api/conversation/<conversation_id>')
def get_conversation(conversation_id):
    return jsonify({'conversation': chatbot.get_conversation(conversation_id)})

@app.route('/api/conversation/<conversation_id>/clear', methods=['POST'])
def clear_conversation(conversation_id):
    return jsonify({'success': chatbot.clear_conversation(conversation_id)})

@app.route('/api/login', methods=['POST'])
@csrf.exempt
def login():
    if limiter:
        try:
            limiter.limit("5 per minute")(lambda: None)()
        except:
            return jsonify({'success': False, 'error': 'Too many login attempts. Please try again later.'}), 429
    try:
        data = request.get_json()
        if not data:
            return jsonify({'success': False, 'error': 'Invalid request format'}), 400
        email = data.get('email', '').strip().lower()
        password = data.get('password', '')
        if not email or not password:
            return jsonify({'success': False, 'error': 'Email and password required'}), 400
        if len(email) > 254 or len(password) > 128:
            return jsonify({'success': False, 'error': 'Invalid input length'}), 400
        user = db.authenticate_user(email, password)
        if user:
            old_sid = session.get('session_id')
            if old_sid:
                try:
                    db.invalidate_session(old_sid)
                except Exception as e:
                    logger.warning(f"Failed to invalidate old session: {e}")
            session.clear()
            sid = db.create_session(user['id'], request.remote_addr or 'unknown', request.headers.get('User-Agent', '')[:255])
            session.permanent = True
            session['user_id'] = user['id']
            session['session_id'] = sid
            session['user_email'] = user['email']
            session['user_name'] = f"{user['first_name']} {user['last_name']}"
            return jsonify({'success': True, 'user': {'id': user['id'], 'email': user['email'], 'name': f"{user['first_name']} {user['last_name']}"}})
        else:
            time.sleep(1)
            return jsonify({'success': False, 'error': 'Invalid credentials'}), 401
    except Exception as e:
        logger.error(f"Login error: {str(e)}")
        return jsonify({'success': False, 'error': 'Server error'}), 500

@app.route('/api/register', methods=['POST'])
@csrf.exempt
def register():
    try:
        if limiter:
            try:
                limiter.limit("3 per minute")(lambda: None)()
            except:
                return jsonify({'success': False, 'error': 'Too many registration attempts. Please try again later.'}), 429
        data = request.get_json()
        if not data:
            return jsonify({'success': False, 'error': 'Invalid request format'}), 400
        required = ['email', 'first_name', 'last_name', 'password']
        if not all(k in data for k in required):
            return jsonify({'success': False, 'error': 'Missing required fields'}), 400
        email = data['email'].strip().lower()
        first = data['first_name'].strip()
        last = data['last_name'].strip()
        pwd = data['password']
        phone = data.get('phone', '').strip() if data.get('phone') else None
        company = data.get('company', '').strip() if data.get('company') else None
        valid, err = SecurityValidator.validate_email(email)
        if not valid:
            return jsonify({'success': False, 'error': err}), 400
        if len(first) < 1 or len(first) > 50:
            return jsonify({'success': False, 'error': 'First name must be 1-50 characters'}), 400
        if len(last) < 1 or len(last) > 50:
            return jsonify({'success': False, 'error': 'Last name must be 1-50 characters'}), 400
        if len(pwd) < 8 or len(pwd) > 128:
            return jsonify({'success': False, 'error': 'Password must be 8-128 characters'}), 400
        if phone and len(phone) > 20:
            return jsonify({'success': False, 'error': 'Phone number too long'}), 400
        if company and len(company) > 100:
            return jsonify({'success': False, 'error': 'Company name too long'}), 400
        uid = db.create_user(email, first, last, pwd, phone, company)
        if uid:
            return jsonify({'success': True, 'message': 'Account created successfully'})
        else:
            return jsonify({'success': False, 'error': 'Email already exists'}), 409
    except Exception as e:
        logger.error(f"Registration error: {str(e)}")
        return jsonify({'success': False, 'error': 'Server error'}), 500

@app.route('/api/user')
def get_current_user():
    uid = session.get('user_id')
    if not uid:
        return jsonify({'success': False, 'error': 'No user logged in'})
    try:
        with db.get_connection() as conn:
            cur = conn.cursor()
            cur.execute('SELECT id, first_name, last_name, email FROM users WHERE id = ? AND is_active = 1', (uid,))
            u = cur.fetchone()
            if u:
                return jsonify({'success': True, 'user': {'id': u['id'], 'name': f"{u['first_name']} {u['last_name']}", 'email': u['email']}})
            else:
                session.clear()
                return jsonify({'success': False, 'error': 'User not found'})
    except Exception as e:
        logger.error(f"Error getting current user: {e}")
        return jsonify({'success': False, 'error': 'Server error'}), 500

@app.route('/api/logout', methods=['POST'])
@csrf.exempt
def logout():
    try:
        sid = session.get('session_id')
        uid = session.get('user_id')
        if sid:
            with db.get_connection() as conn:
                conn.execute('UPDATE sessions SET is_active = 0, logged_out_at = CURRENT_TIMESTAMP WHERE id = ? AND user_id = ?', (sid, uid))
        session.clear()
        return jsonify({'success': True, 'message': 'Logged out successfully'})
    except Exception as e:
        logger.error(f"Logout error: {str(e)}")
        session.clear()
        return jsonify({'success': True, 'message': 'Logged out successfully'})

@app.route('/api/user')
def get_user():
    uid = session.get('user_id')
    if not uid:
        return jsonify({'authenticated': False})
    return jsonify({'authenticated': True, 'user': {'id': uid, 'email': session.get('user_email'), 'name': session.get('user_name')}})

@app.route('/api/conversations')
def get_conversations():
    uid = session.get('user_id')
    if not uid:
        return jsonify({'success': False, 'error': 'Not authenticated'}), 401
    return jsonify({'conversations': db.get_user_conversations(uid)})

@app.route('/api/health')
def health_check():
    try:
        with db.get_connection() as conn:
            conn.execute('SELECT 1')
            db_ok = True
    except:
        db_ok = False
    rag_ok = False
    rag_stats = {}
    try:
        rag_stats = rag_helper.get_knowledge_base_stats()
        rag_ok = True
    except Exception as e:
        rag_stats = {'error': str(e)}
    return jsonify({'flask_status': 'running', 'ollama_status': 'not_used', 'database_status': 'running' if db_ok else 'error', 'rag_status': 'running' if rag_ok else 'error', 'rag_stats': rag_stats})

@app.route('/api/health/ollama')
def ollama_health_check():
    return jsonify({'ollama_healthy': True, 'timestamp': datetime.now().isoformat(), 'message': 'Ollama not used (Hugging Face backend)', 'recommendation': 'All good!'})

@app.route('/api/knowledge-base/stats')
def kb_stats():
    try:
        return jsonify({'success': True, 'stats': rag_helper.get_knowledge_base_stats()})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/knowledge-base/reindex', methods=['POST'])
@csrf.exempt
@require_role('admin')
def kb_reindex():
    try:
        force = request.json.get('force', False) if request.json else False
        res = rag_helper.ensure_vector_index(force_reindex=force)
        return jsonify({'success': True, 'result': res})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/knowledge-base/search', methods=['POST'])
@csrf.exempt
@require_role('admin')
def kb_search():
    data = request.get_json()
    q = data.get('query')
    if not q:
        return jsonify({'success': False, 'error': 'Query required'}), 400
    try:
        kw_ctx = rag_helper._get_keyword_context(q, max_docs=3)
        vec_ctx = ""
        vec_res = []
        if rag_helper.use_vector_search and rag_helper.vector_rag:
            vec_ctx = rag_helper.get_relevant_context(q)
            vec_res = rag_helper.vector_rag.semantic_search(q, n_results=5)
        return jsonify({'success': True, 'query': q, 'keyword_context_length': len(kw_ctx), 'vector_context_length': len(vec_ctx), 'vector_results': vec_res[:3], 'vector_search_available': rag_helper.use_vector_search})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

# ---------- Ticket Management API ----------
@app.route('/api/tickets/create', methods=['POST'])
def create_ticket():
    if 'user_id' not in session:
        return jsonify({'success': False, 'error': 'Auth required'}), 401
    data = request.get_json()
    subject = data.get('subject')
    desc = data.get('description')
    conv_id = data.get('conversation_id')
    priority = data.get('priority', 'medium')
    if not subject or not desc:
        return jsonify({'success': False, 'error': 'Subject and description required'}), 400
    if priority not in ['low','medium','high','urgent']:
        priority = 'medium'
    uid = session['user_id']
    cat = db.categorize_ticket_content(f"{subject} {desc}")
    tn = db.create_support_ticket(uid, subject, desc, cat, conv_id, priority)
    if conv_id:
        msgs = db.get_conversation_messages(conv_id)
        if msgs:
            ctx = "Ticket created from conversation. Recent messages:\n"
            for msg in msgs[-3:]:
                ctx += f"[{msg['sender']}]: {msg['message'][:200]}...\n"
            tinfo = db.get_ticket_by_number(tn)
            if tinfo:
                db.add_ticket_update(tinfo['id'], uid, ctx, 'note', is_internal=False)
    return jsonify({'success': True, 'ticket_number': tn, 'category': cat, 'priority': priority})

@app.route('/api/tickets/<ticket_number>')
def get_ticket(ticket_number):
    if 'user_id' not in session:
        return jsonify({'success': False, 'error': 'Auth required'}), 401
    ticket = db.get_ticket_by_number(ticket_number)
    if not ticket:
        return jsonify({'success': False, 'error': 'Ticket not found'}), 404
    if ticket['user_id'] != session['user_id']:
        return jsonify({'success': False, 'error': 'Access denied'}), 403
    updates = db.get_ticket_updates(ticket['id'], include_internal=False)
    return jsonify({'success': True, 'ticket': ticket, 'updates': updates})

@app.route('/api/tickets/<int:ticket_id>/update', methods=['POST'])
@csrf.exempt
def add_ticket_update(ticket_id):
    if 'user_id' not in session:
        return jsonify({'success': False, 'error': 'Auth required'}), 401
    data = request.get_json()
    msg = data.get('message')
    if not msg:
        return jsonify({'success': False, 'error': 'Message required'}), 400
    uid = session['user_id']
    with db.get_connection() as conn:
        cur = conn.cursor()
        cur.execute('SELECT user_id FROM support_tickets WHERE id = ?', (ticket_id,))
        row = cur.fetchone()
        if not row:
            return jsonify({'success': False, 'error': 'Ticket not found'}), 404
        if row['user_id'] != uid:
            return jsonify({'success': False, 'error': 'Access denied'}), 403
    db.add_ticket_update(ticket_id, uid, msg, 'note', is_internal=False)
    return jsonify({'success': True})

@app.route('/api/tickets/user')
def get_user_tickets():
    if 'user_id' not in session:
        return jsonify({'success': False, 'error': 'Auth required'}), 401
    tickets = db.get_user_tickets(session['user_id'])
    return jsonify({'success': True, 'tickets': tickets})

@app.route('/api/tickets/categories')
def get_ticket_categories():
    with db.get_connection() as conn:
        cur = conn.cursor()
        cur.execute('SELECT name, description, default_priority FROM ticket_categories WHERE is_active = 1 ORDER BY name')
        cats = [dict(row) for row in cur.fetchall()]
    return jsonify({'success': True, 'categories': cats})

@app.route('/api/tickets/<int:ticket_id>/escalate', methods=['POST'])
def escalate_ticket(ticket_id):
    if 'user_id' not in session:
        return jsonify({'success': False, 'error': 'User not authenticated'}), 401
    data = request.get_json()
    reason = data.get('reason', 'Manual escalation requested')
    with db.get_connection() as conn:
        cur = conn.cursor()
        cur.execute('SELECT user_id FROM support_tickets WHERE id = ?', (ticket_id,))
        row = cur.fetchone()
        if not row or row['user_id'] != session['user_id']:
            return jsonify({'success': False, 'error': 'Ticket not found or access denied'}), 404
    ok = db.escalate_ticket(ticket_id, reason, session['user_id'])
    if ok:
        return jsonify({'success': True, 'message': 'Ticket escalated successfully'})
    return jsonify({'success': False, 'error': 'Failed to escalate ticket'}), 500

@app.route('/api/tickets/<int:ticket_id>/sla')
def get_ticket_sla(ticket_id):
    if 'user_id' not in session:
        return jsonify({'success': False, 'error': 'User not authenticated'}), 401
    with db.get_connection() as conn:
        cur = conn.cursor()
        cur.execute('SELECT user_id FROM support_tickets WHERE id = ?', (ticket_id,))
        row = cur.fetchone()
        if not row or row['user_id'] != session['user_id']:
            return jsonify({'success': False, 'error': 'Ticket not found or access denied'}), 404
    sla = db.get_sla_metrics(ticket_id)
    return jsonify({'success': True, 'sla_metrics': sla})

@app.route('/api/tickets/<int:ticket_id>/escalation-check')
def check_ticket_escalation(ticket_id):
    if 'user_id' not in session:
        return jsonify({'success': False, 'error': 'User not authenticated'}), 401
    with db.get_connection() as conn:
        cur = conn.cursor()
        cur.execute('SELECT user_id FROM support_tickets WHERE id = ?', (ticket_id,))
        row = cur.fetchone()
        if not row or row['user_id'] != session['user_id']:
            return jsonify({'success': False, 'error': 'Ticket not found or access denied'}), 404
    esc = db.check_escalation_needed(ticket_id)
    return jsonify({'success': True, 'escalation_check': esc})

# ---------- Admin API ----------
def build_safe_where_clause(filters, allowed):
    where = []
    params = []
    for col, val in filters.items():
        if col in allowed and val:
            where.append(f'st.{col} = ?')
            params.append(val)
    sql = 'WHERE ' + ' AND '.join(where) if where else ''
    return sql, params

@app.route('/api/admin/tickets', methods=['GET'])
@require_role('admin')
def admin_get_all_tickets():
    try:
        page = max(1, int(request.args.get('page', 1)))
        limit = min(int(request.args.get('limit', 20)), 100)
        allowed = ['status', 'priority', 'category']
        filters = {}
        for f in allowed:
            val = request.args.get(f, '').strip()
            if val:
                if f == 'status' and val not in ['open','in_progress','resolved','closed']:
                    return jsonify({'error': 'Invalid status'}), 400
                if f == 'priority' and val not in ['low','medium','high','urgent']:
                    return jsonify({'error': 'Invalid priority'}), 400
                filters[f] = val
        offset = (page-1)*limit
        with db.get_connection() as conn:
            cur = conn.cursor()
            where, params = build_safe_where_clause(filters, allowed)
            q = f'''
                SELECT st.*, u.first_name, u.last_name, u.email
                FROM support_tickets st
                JOIN users u ON st.user_id = u.id
                {where}
                ORDER BY st.created_at DESC
                LIMIT ? OFFSET ?
            '''
            cur.execute(q, params + [limit, offset])
            tickets = [dict(row) for row in cur.fetchall()]
            count_q = f'SELECT COUNT(*) FROM support_tickets st JOIN users u ON st.user_id = u.id {where}'
            cur.execute(count_q, params)
            total = cur.fetchone()[0]
        return jsonify({'success': True, 'tickets': tickets, 'pagination': {'page': page, 'limit': limit, 'total': total, 'pages': (total+limit-1)//limit}})
    except Exception as e:
        logger.error(f"Admin tickets error: {e}")
        return jsonify({'success': False, 'error': 'Failed to fetch tickets'}), 500

@app.route('/api/admin/tickets/<int:ticket_id>/assign', methods=['PUT'])
@require_role('admin')
def admin_assign_ticket(ticket_id):
    data = request.get_json()
    agent = data.get('assigned_agent', '')
    with db.get_connection() as conn:
        conn.execute('UPDATE support_tickets SET assigned_agent = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?', (agent, ticket_id))
        conn.execute('INSERT INTO ticket_updates (ticket_id, user_id, update_type, message, old_value, new_value, is_internal) VALUES (?, NULL, "assignment", ?, NULL, ?, 1)', (ticket_id, f'Ticket assigned to {agent}', agent))
    return jsonify({'success': True})

@app.route('/api/admin/tickets/<int:ticket_id>/status', methods=['PUT'])
@require_role('admin')
def admin_update_ticket_status(ticket_id):
    data = request.get_json()
    new_status = data.get('status')
    notes = data.get('resolution_notes', '')
    if not new_status:
        return jsonify({'success': False, 'error': 'Status required'}), 400
    ok = db.update_ticket_status(ticket_id, new_status, None, notes)
    if ok:
        return jsonify({'success': True})
    return jsonify({'success': False, 'error': 'Failed to update status'}), 500

@app.route('/api/admin/tickets/<int:ticket_id>/reply', methods=['POST'])
@require_role('admin')
def admin_reply_ticket(ticket_id):
    data = request.get_json()
    msg = data.get('message')
    internal = data.get('is_internal', False)
    if not msg:
        return jsonify({'success': False, 'error': 'Message required'}), 400
    db.add_ticket_update(ticket_id, session.get('user_id'), msg, 'admin_reply', is_internal=internal)
    return jsonify({'success': True})

@app.route('/api/admin/tickets/stats')
@require_role('admin')
def admin_ticket_stats():
    with db.get_connection() as conn:
        cur = conn.cursor()
        cur.execute('SELECT COUNT(*) as total FROM support_tickets')
        total = cur.fetchone()['total']
        cur.execute('SELECT COUNT(*) as open FROM support_tickets WHERE status="open"')
        open_t = cur.fetchone()['open']
        cur.execute('SELECT COUNT(*) as in_progress FROM support_tickets WHERE status="in_progress"')
        in_prog = cur.fetchone()['in_progress']
        cur.execute('SELECT COUNT(*) as resolved FROM support_tickets WHERE status="resolved"')
        resolved = cur.fetchone()['resolved']
        return jsonify({'success': True, 'stats': {'overall': {'total_tickets': total, 'open_tickets': open_t, 'in_progress_tickets': in_prog, 'resolved_tickets': resolved}}})

# ---------- Chat-ticket integration ----------
@app.route('/api/chat/create-ticket', methods=['POST'])
def chat_create_ticket():
    uid = session.get('user_id')
    if not uid:
        return jsonify({'success': False, 'error': 'User must be logged in'}), 401
    data = request.get_json()
    subject = data.get('subject')
    desc = data.get('description')
    cat = data.get('category', 'General')
    prio = data.get('priority', 'medium')
    cid = data.get('conversation_id')
    if not subject or not desc:
        return jsonify({'success': False, 'error': 'Subject and description required'}), 400
    conv_ctx = ""
    if cid:
        conv = chatbot.get_conversation(cid)
        if conv:
            conv_ctx = "\n\n--- CHAT CONTEXT ---\n" + "\n".join([f"{msg['role'].upper()}: {msg['content']}" for msg in conv[-5:]]) + "\n--- END CHAT CONTEXT ---"
    full_desc = desc + conv_ctx
    tn = db.create_support_ticket(uid, subject, full_desc, cat, cid, prio)
    if tn:
        return jsonify({'success': True, 'ticket_number': tn, 'message': f'Ticket {tn} created'})
    return jsonify({'success': False, 'error': 'Failed to create ticket'}), 500

@app.route('/api/chat/user-tickets')
def chat_user_tickets():
    uid = session.get('user_id')
    if not uid:
        return jsonify({'success': False, 'error': 'User not logged in'}), 401
    ctx = chatbot.get_user_ticket_context(uid)
    return jsonify({'success': True, 'tickets': ctx['tickets'] if ctx else [], 'user_name': ctx['user_name'] if ctx else None})

@app.route('/api/conversation/end', methods=['POST'])
@csrf.exempt
def end_conversation():
    data = request.get_json() or {}
    cid = data.get('conversation_id')
    if not cid:
        return jsonify({'success': False, 'error': 'conversation_id required'}), 400
    chatbot._add_conversation_summary_to_tickets(cid)
    return jsonify({'success': True, 'message': 'Conversation ended and summary added'})

@app.route('/api/admin/reindex-knowledge-base', methods=['POST'])
@csrf.exempt
def reindex_knowledge_base():
    try:
        from scripts.knowledge_base_manager import KnowledgeBaseManager
        from scripts.vector_rag_manager import VectorRAGManager
        kb = KnowledgeBaseManager('/app/knowledge_base')
        vec = VectorRAGManager('/app/vector_db')
        docs = kb.scan_documents()
        all_docs = []
        for cat, info in docs.items():
            for doc in info['documents']:
                content = kb.load_document_content(doc['path'])
                if content:
                    all_docs.append({'id': doc['path'], 'content': content, 'metadata': doc})
        vec.index_documents(all_docs)
        return jsonify({'success': True, 'message': f'Re-indexed {len(all_docs)} documents', 'document_count': len(all_docs), 'categories': list(docs.keys())})
    except Exception as e:
        logger.error(f"Reindex error: {e}")
        return jsonify({'success': False, 'error': str(e)}), 500

@app.route('/api/product/<product_name>')
def get_product_specs(product_name):
    mapping = {
        'usb-c-cable': 'knowledge_base/product_manuals/usb_c_cables.md',
        'usb-c-standard': 'knowledge_base/product_manuals/usb_c_cables.md',
        'usb-c-to-usb-a': 'knowledge_base/product_manuals/usb_c_cables.md',
        '4k-hdmi-cable': 'knowledge_base/product_manuals/hdmi_cables.md',
        'hdmi-standard': 'knowledge_base/product_manuals/hdmi_cables.md',
        'hdmi-usb-c-cable': 'knowledge_base/product_manuals/hdmi_cables.md',
        'mini-hdmi-cable': 'knowledge_base/product_manuals/hdmi_cables.md',
        'micro-hdmi-cable': 'knowledge_base/product_manuals/hdmi_cables.md',
        'lightning-cable': 'knowledge_base/product_manuals/lightning_cables.md',
        'charging-hub': 'knowledge_base/product_manuals/charging_hub.md',
        'wireless-charging': 'knowledge_base/product_manuals/wireless_charging_pad.md',
        'usb-c-hub': 'knowledge_base/product_manuals/usb_c_hub_adapter.md',
        'usb-c-hdmi-adapter': 'knowledge_base/product_manuals/usb_c_hdmi_adapter.md',
        'audio-cable': 'knowledge_base/product_manuals/audio_cable.md',
        'usb-c-audio-adapter': 'knowledge_base/product_manuals/usb_c_audio_adapter.md'
    }
    path = mapping.get(product_name)
    if not path or not os.path.exists(path):
        return jsonify({'success': False, 'error': 'Product not found'}), 404
    with open(path, 'r', encoding='utf-8') as f:
        content = f.read()
    # Extract relevant section if multiple products share the same file
    if product_name in ['usb-c-cable', 'usb-c-standard', 'usb-c-to-usb-a']:
        sections = content.split('##')
        for s in sections:
            if 'TMC-USBC-100W-6FT' in s and product_name == 'usb-c-cable':
                content = '##' + s
                break
            elif 'TMC-USBC-60W-3FT' in s and product_name == 'usb-c-standard':
                content = '##' + s
                break
            elif 'TMC-USBC-A-FAST' in s and product_name == 'usb-c-to-usb-a':
                content = '##' + s
                break
    elif product_name.startswith('hdmi') or product_name == '4k-hdmi-cable':
        sections = content.split('##')
        for s in sections:
            if ('TMC-HDMI-8K-10FT' in s and product_name == '4k-hdmi-cable') or \
               ('TMC-HDMI-4K-6FT' in s and product_name == 'hdmi-standard') or \
               ('Mini HDMI' in s and product_name == 'mini-hdmi-cable') or \
               ('Micro HDMI' in s and product_name == 'micro-hdmi-cable') or \
               ('USB-C to HDMI' in s and product_name == 'hdmi-usb-c-cable'):
                content = '##' + s
                break
    return jsonify({'success': True, 'product_name': product_name, 'specifications': content.strip()})

# ---------- Session cleanup ----------
def periodic_session_cleanup():
    try:
        cleaned = db.cleanup_expired_sessions()
        if cleaned:
            logger.info(f"Cleaned up {cleaned} expired sessions")
    except Exception as e:
        logger.error(f"Session cleanup error: {e}")
    threading.Timer(3600, periodic_session_cleanup).start()

periodic_session_cleanup()

if __name__ == '__main__':
    logger.info("Starting TMC Chatbot with Hugging Face backend")
    app.run(debug=False, host='0.0.0.0', port=7860)