"""
Session-Blueprint für das 3D-Druck-Management-System

Dieses Modul enthält alle Routen und Funktionen für Session-Management.
"""

from flask import Blueprint, jsonify, request, session
from flask_login import login_required, current_user
from datetime import datetime, timedelta
from models import User, get_db_session, SystemLog
from utils.logging_config import get_logger
from utils.settings import SESSION_LIFETIME

# Blueprint erstellen
sessions_blueprint = Blueprint('sessions', __name__, url_prefix='/api/session')

# Logger initialisieren
sessions_logger = get_logger("sessions")

@sessions_blueprint.route('/heartbeat', methods=['POST'])
@login_required
def heartbeat():
    """
    Session-Heartbeat zum Aktualisieren der letzten Aktivität.
    Verhindert automatischen Logout bei aktiven Benutzern.
    """
    try:
        # Session-Aktivität aktualisieren
        session['last_activity'] = datetime.now().isoformat()
        session.permanent = True
        
        # Benutzer-Aktivität in Datenbank aktualisieren
        with get_db_session() as db_session:
            user = db_session.query(User).filter_by(id=current_user.id).first()
            if user:
                user.last_activity = datetime.now()
                db_session.commit()
        
        # Verbleibende Session-Zeit berechnen
        session_start = session.get('session_start')
        if session_start:
            elapsed = (datetime.now() - datetime.fromisoformat(session_start)).total_seconds()
            remaining = max(0, SESSION_LIFETIME.total_seconds() - elapsed)
        else:
            remaining = SESSION_LIFETIME.total_seconds()
        
        return jsonify({
            'success': True,
            'remaining_seconds': int(remaining),
            'session_lifetime': int(SESSION_LIFETIME.total_seconds())
        })
        
    except Exception as e:
        sessions_logger.error(f"Fehler beim Session-Heartbeat: {str(e)}")
        return jsonify({'error': 'Fehler beim Aktualisieren der Session'}), 500

@sessions_blueprint.route('/status', methods=['GET'])
@login_required
def status():
    """Gibt den aktuellen Session-Status zurück"""
    try:
        # Session-Informationen sammeln
        session_start = session.get('session_start')
        last_activity = session.get('last_activity')
        
        # Verbleibende Zeit berechnen
        if session_start:
            elapsed = (datetime.now() - datetime.fromisoformat(session_start)).total_seconds()
            remaining = max(0, SESSION_LIFETIME.total_seconds() - elapsed)
        else:
            remaining = SESSION_LIFETIME.total_seconds()
        
        # Inaktivitätszeit berechnen
        if last_activity:
            inactive_seconds = (datetime.now() - datetime.fromisoformat(last_activity)).total_seconds()
        else:
            inactive_seconds = 0
        
        return jsonify({
            'success': True,
            'user': {
                'id': current_user.id,
                'username': current_user.username,
                'email': current_user.email,
                'name': current_user.name,
                'is_admin': current_user.is_admin
            },
            'session': {
                'start_time': session_start,
                'last_activity': last_activity,
                'remaining_seconds': int(remaining),
                'inactive_seconds': int(inactive_seconds),
                'lifetime_seconds': int(SESSION_LIFETIME.total_seconds()),
                'is_permanent': session.permanent
            }
        })
        
    except Exception as e:
        sessions_logger.error(f"Fehler beim Abrufen des Session-Status: {str(e)}")
        return jsonify({'error': 'Fehler beim Abrufen des Session-Status'}), 500

@sessions_blueprint.route('/extend', methods=['POST'])
@login_required
def extend():
    """Verlängert die aktuelle Session"""
    try:
        # Nur Admins können Sessions verlängern
        if not current_user.is_admin:
            return jsonify({'error': 'Keine Berechtigung zum Verlängern der Session'}), 403
        
        # Session-Start zurücksetzen
        session['session_start'] = datetime.now().isoformat()
        session['last_activity'] = datetime.now().isoformat()
        session.permanent = True
        
        # SystemLog erstellen
        with get_db_session() as db_session:
            SystemLog.log_system_event(
                level="INFO",
                message=f"Session verlängert für Benutzer {current_user.username}",
                module="sessions",
                user_id=current_user.id
            )
            db_session.commit()
        
        sessions_logger.info(f"Session verlängert für Benutzer {current_user.id}")
        
        return jsonify({
            'success': True,
            'message': 'Session wurde verlängert',
            'new_lifetime_seconds': int(SESSION_LIFETIME.total_seconds())
        })
        
    except Exception as e:
        sessions_logger.error(f"Fehler beim Verlängern der Session: {str(e)}")
        return jsonify({'error': 'Fehler beim Verlängern der Session'}), 500