import logging
from datetime import datetime
from zoneinfo import ZoneInfo
from flask import Blueprint, render_template, request, redirect, session, url_for, flash, jsonify

import config
from auth.decorators import login_required
from utils.audit import log_audit
from utils.network import get_client_ip
from db import get_connection, get_db_connection, get_db_cursor

# Create Blueprint
resource_bp = Blueprint('resources', __name__)


@resource_bp.route('/resources')
@login_required
def resources():
    """Zeigt die Ressourcenpool-Übersicht"""
    conn = get_connection()
    cur = conn.cursor()
    
    try:
        # Filter aus Query-Parametern
        resource_type = request.args.get('type', 'all')
        status_filter = request.args.get('status', 'all')
        search_query = request.args.get('search', '')
        show_test = request.args.get('show_test', 'false') == 'true'
        
        # Basis-Query
        query = """
            SELECT 
                rp.id,
                rp.resource_type,
                rp.resource_value,
                rp.status,
                rp.is_test,
                rp.allocated_to_license,
                rp.created_at,
                rp.status_changed_at,
                rp.status_changed_by,
                l.customer_name,
                l.license_type
            FROM resource_pools rp
            LEFT JOIN licenses l ON rp.allocated_to_license = l.id
            WHERE 1=1
        """
        
        params = []
        
        # Filter anwenden
        if resource_type != 'all':
            query += " AND rp.resource_type = %s"
            params.append(resource_type)
        
        if status_filter != 'all':
            query += " AND rp.status = %s"
            params.append(status_filter)
        
        if search_query:
            query += " AND (rp.resource_value ILIKE %s OR l.customer_name ILIKE %s)"
            params.extend([f'%{search_query}%', f'%{search_query}%'])
        
        if not show_test:
            query += " AND rp.is_test = false"
        
        query += " ORDER BY rp.resource_type, rp.resource_value"
        
        cur.execute(query, params)
        
        resources_list = []
        for row in cur.fetchall():
            resources_list.append({
                'id': row[0],
                'resource_type': row[1],
                'resource_value': row[2],
                'status': row[3],
                'is_test': row[4],
                'allocated_to_license': row[5],
                'created_at': row[6],
                'status_changed_at': row[7],
                'status_changed_by': row[8],
                'customer_name': row[9],
                'license_type': row[10]
            })
        
        # Statistiken
        cur.execute("""
            SELECT 
                resource_type,
                status,
                is_test,
                COUNT(*) as count
            FROM resource_pools
            GROUP BY resource_type, status, is_test
        """)
        
        stats = {}
        for row in cur.fetchall():
            res_type = row[0]
            status = row[1]
            is_test = row[2]
            count = row[3]
            
            if res_type not in stats:
                stats[res_type] = {'available': 0, 'allocated': 0, 'quarantined': 0, 'test': 0, 'prod': 0}
            
            stats[res_type][status] = stats[res_type].get(status, 0) + count
            if is_test:
                stats[res_type]['test'] += count
            else:
                stats[res_type]['prod'] += count
        
        return render_template('resources.html', 
                             resources=resources_list,
                             stats=stats,
                             resource_type=resource_type,
                             status_filter=status_filter,
                             search_query=search_query,
                             show_test=show_test)
        
    except Exception as e:
        logging.error(f"Fehler beim Laden der Ressourcen: {str(e)}")
        flash('Fehler beim Laden der Ressourcen!', 'error')
        return redirect(url_for('admin.dashboard'))
    finally:
        cur.close()
        conn.close()


@resource_bp.route('/resources/add', methods=['GET', 'POST'])
@login_required
def add_resource():
    """Neue Ressource hinzufügen"""
    if request.method == 'POST':
        try:
            with get_db_connection() as conn:
                cur = conn.cursor()
                try:
                    resource_type = request.form['resource_type']
                    resource_value = request.form['resource_value'].strip()
                    is_test = 'is_test' in request.form
                    
                    # Prüfe ob Ressource bereits existiert
                    cur.execute("""
                        SELECT id FROM resource_pools 
                        WHERE resource_type = %s AND resource_value = %s
                    """, (resource_type, resource_value))
                    
                    if cur.fetchone():
                        flash(f'Ressource {resource_value} existiert bereits!', 'error')
                        return redirect(url_for('resources.add_resource'))
                    
                    # Füge neue Ressource hinzu (ohne created_by)
                    cur.execute("""
                        INSERT INTO resource_pools (resource_type, resource_value, status, is_test, status_changed_by)
                        VALUES (%s, %s, 'available', %s, %s)
                        RETURNING id
                    """, (resource_type, resource_value, is_test, session.get('username', 'system')))
                    
                    resource_id = cur.fetchone()[0]
                    conn.commit()
                    
                    # Audit-Log
                    log_audit('CREATE', 'resource', resource_id,
                             new_values={
                                 'resource_type': resource_type,
                                 'resource_value': resource_value,
                                 'is_test': is_test
                             })
                    
                    flash(f'Ressource {resource_value} erfolgreich hinzugefügt!', 'success')
                    return redirect(url_for('resources.resources'))
                finally:
                    cur.close()
                    
        except Exception as e:
            import traceback
            logging.error(f"Fehler beim Hinzufügen der Ressource: {str(e)}")
            logging.error(f"Traceback: {traceback.format_exc()}")
            flash(f'Fehler: {str(e)}', 'error')
            return redirect(url_for('resources.resources'))
    
    return render_template('add_resources.html')


@resource_bp.route('/resources/quarantine/<int:resource_id>', methods=['POST'])
@login_required
def quarantine_resource(resource_id):
    """Ressource in Quarantäne versetzen"""
    conn = get_connection()
    cur = conn.cursor()
    
    try:
        reason = request.form.get('reason', '')
        
        # Hole aktuelle Ressourcen-Info
        cur.execute("""
            SELECT resource_value, status, allocated_to_license 
            FROM resource_pools WHERE id = %s
        """, (resource_id,))
        resource = cur.fetchone()
        
        if not resource:
            flash('Ressource nicht gefunden!', 'error')
            return redirect(url_for('resources.resources'))
        
        # Setze Status auf quarantined
        cur.execute("""
            UPDATE resource_pools 
            SET status = 'quarantined', 
                allocated_to_license = NULL,
                status_changed_at = CURRENT_TIMESTAMP,
                status_changed_by = %s,
                quarantine_reason = %s
            WHERE id = %s
        """, (session['username'], reason, resource_id))
        
        # Wenn die Ressource zugewiesen war, entferne die Zuweisung
        if resource[2]:  # allocated_to_license
            cur.execute("""
                DELETE FROM license_resources 
                WHERE license_id = %s AND resource_id = %s
            """, (resource[2], resource_id))
            
            # History-Eintrag
            cur.execute("""
                INSERT INTO resource_history (resource_id, license_id, action, action_by, notes, ip_address)
                VALUES (%s, %s, 'quarantined', %s, %s, %s)
            """, (resource_id, resource[2], session['username'], reason, get_client_ip()))
        
        conn.commit()
        
        # Audit-Log
        log_audit('QUARANTINE', 'resource', resource_id,
                 old_values={'status': resource[1]},
                 new_values={'status': 'quarantined', 'reason': reason})
        
        flash(f'Ressource {resource[0]} in Quarantäne versetzt!', 'warning')
        
    except Exception as e:
        conn.rollback()
        logging.error(f"Fehler beim Quarantänisieren der Ressource: {str(e)}")
        flash('Fehler beim Quarantänisieren der Ressource!', 'error')
    finally:
        cur.close()
        conn.close()
    
    return redirect(url_for('resources.resources'))


@resource_bp.route('/resources/release', methods=['POST'])
@login_required
def release_resources():
    """Ressourcen aus Quarantäne freigeben oder von Lizenz entfernen"""
    conn = get_connection()
    cur = conn.cursor()
    
    try:
        resource_ids = request.form.getlist('resource_ids[]')
        action = request.form.get('action', 'release')
        
        if not resource_ids:
            flash('Keine Ressourcen ausgewählt!', 'error')
            return redirect(url_for('resources.resources'))
        
        for resource_id in resource_ids:
            # Hole aktuelle Ressourcen-Info
            cur.execute("""
                SELECT resource_value, status, allocated_to_license 
                FROM resource_pools WHERE id = %s
            """, (resource_id,))
            resource = cur.fetchone()
            
            if resource:
                # Setze Status auf available
                cur.execute("""
                    UPDATE resource_pools 
                    SET status = 'available', 
                        allocated_to_license = NULL,
                        status_changed_at = CURRENT_TIMESTAMP,
                        status_changed_by = %s,
                        quarantine_reason = NULL
                    WHERE id = %s
                """, (session['username'], resource_id))
                
                # Entferne Lizenz-Zuweisung wenn vorhanden
                if resource[2]:  # allocated_to_license
                    cur.execute("""
                        DELETE FROM license_resources 
                        WHERE license_id = %s AND resource_id = %s
                    """, (resource[2], resource_id))
                    
                    # History-Eintrag
                    cur.execute("""
                        INSERT INTO resource_history (resource_id, license_id, action, action_by, ip_address)
                        VALUES (%s, %s, 'released', %s, %s)
                    """, (resource_id, resource[2], session['username'], get_client_ip()))
                
                # Audit-Log
                log_audit('RELEASE', 'resource', resource_id,
                         old_values={'status': resource[1]},
                         new_values={'status': 'available'})
        
        conn.commit()
        flash(f'{len(resource_ids)} Ressource(n) freigegeben!', 'success')
        
    except Exception as e:
        conn.rollback()
        logging.error(f"Fehler beim Freigeben der Ressourcen: {str(e)}")
        flash('Fehler beim Freigeben der Ressourcen!', 'error')
    finally:
        cur.close()
        conn.close()
    
    return redirect(url_for('resources.resources'))


@resource_bp.route('/resources/history/<int:resource_id>')
@login_required
def resource_history(resource_id):
    """Zeigt die Historie einer Ressource"""
    conn = get_connection()
    cur = conn.cursor()
    
    try:
        # Hole Ressourcen-Info
        cur.execute("""
            SELECT resource_type, resource_value, status, is_test
            FROM resource_pools WHERE id = %s
        """, (resource_id,))
        resource = cur.fetchone()
        
        if not resource:
            flash('Ressource nicht gefunden!', 'error')
            return redirect(url_for('resources.resources'))
        
        # Hole Historie
        cur.execute("""
            SELECT 
                rh.action,
                rh.action_timestamp,
                rh.action_by,
                rh.notes,
                rh.ip_address,
                l.license_key,
                c.name as customer_name
            FROM resource_history rh
            LEFT JOIN licenses l ON rh.license_id = l.id
            LEFT JOIN customers c ON l.customer_id = c.id
            WHERE rh.resource_id = %s
            ORDER BY rh.action_timestamp DESC
        """, (resource_id,))
        
        history = []
        for row in cur.fetchall():
            history.append({
                'action': row[0],
                'timestamp': row[1],
                'by': row[2],
                'notes': row[3],
                'ip_address': row[4],
                'license_key': row[5],
                'customer_name': row[6]
            })
        
        return render_template('resource_history.html',
                             resource={
                                 'id': resource_id,
                                 'type': resource[0],
                                 'value': resource[1],
                                 'status': resource[2],
                                 'is_test': resource[3]
                             },
                             history=history)
        
    except Exception as e:
        logging.error(f"Fehler beim Laden der Ressourcen-Historie: {str(e)}")
        flash('Fehler beim Laden der Historie!', 'error')
        return redirect(url_for('resources.resources'))
    finally:
        cur.close()
        conn.close()


@resource_bp.route('/resources/metrics')
@login_required
def resource_metrics():
    """Zeigt Metriken und Statistiken zu Ressourcen"""
    conn = get_connection()
    cur = conn.cursor()
    
    try:
        # Allgemeine Statistiken
        cur.execute("""
            SELECT 
                resource_type,
                status,
                is_test,
                COUNT(*) as count
            FROM resource_pools
            GROUP BY resource_type, status, is_test
            ORDER BY resource_type, status
        """)
        
        general_stats = {}
        for row in cur.fetchall():
            res_type = row[0]
            if res_type not in general_stats:
                general_stats[res_type] = {
                    'total': 0,
                    'available': 0,
                    'allocated': 0,
                    'quarantined': 0,
                    'test': 0,
                    'production': 0
                }
            
            general_stats[res_type]['total'] += row[3]
            general_stats[res_type][row[1]] += row[3]
            if row[2]:
                general_stats[res_type]['test'] += row[3]
            else:
                general_stats[res_type]['production'] += row[3]
        
        # Zuweisungs-Statistiken
        cur.execute("""
            SELECT 
                rp.resource_type,
                COUNT(DISTINCT l.customer_id) as unique_customers,
                COUNT(DISTINCT rp.allocated_to_license) as unique_licenses
            FROM resource_pools rp
            JOIN licenses l ON rp.allocated_to_license = l.id
            WHERE rp.status = 'allocated'
            GROUP BY rp.resource_type
        """)
        
        allocation_stats = {}
        for row in cur.fetchall():
            allocation_stats[row[0]] = {
                'unique_customers': row[1],
                'unique_licenses': row[2]
            }
        
        # Historische Daten (letzte 30 Tage)
        cur.execute("""
            SELECT 
                DATE(action_timestamp) as date,
                action,
                COUNT(*) as count
            FROM resource_history
            WHERE action_timestamp >= CURRENT_DATE - INTERVAL '30 days'
            GROUP BY DATE(action_timestamp), action
            ORDER BY date, action
        """)
        
        historical_data = {}
        for row in cur.fetchall():
            date_str = row[0].strftime('%Y-%m-%d')
            if date_str not in historical_data:
                historical_data[date_str] = {}
            historical_data[date_str][row[1]] = row[2]
        
        # Top-Kunden nach Ressourcennutzung
        cur.execute("""
            SELECT 
                c.name,
                rp.resource_type,
                COUNT(*) as count
            FROM resource_pools rp
            JOIN licenses l ON rp.allocated_to_license = l.id
            JOIN customers c ON l.customer_id = c.id
            WHERE rp.status = 'allocated'
            GROUP BY c.name, rp.resource_type
            ORDER BY count DESC
            LIMIT 20
        """)
        
        top_customers = []
        for row in cur.fetchall():
            top_customers.append({
                'customer': row[0],
                'resource_type': row[1],
                'count': row[2]
            })
        
        return render_template('resource_metrics.html',
                             general_stats=general_stats,
                             allocation_stats=allocation_stats,
                             historical_data=historical_data,
                             top_customers=top_customers)
        
    except Exception as e:
        logging.error(f"Fehler beim Laden der Ressourcen-Metriken: {str(e)}")
        flash('Fehler beim Laden der Metriken!', 'error')
        return redirect(url_for('resources.resources'))
    finally:
        cur.close()
        conn.close()


@resource_bp.route('/resources/report', methods=['GET'])
@login_required
def resource_report():
    """Generiert einen Ressourcen-Report"""
    from io import BytesIO
    import xlsxwriter
    
    conn = get_connection()
    cur = conn.cursor()
    
    try:
        # Erstelle Excel-Datei im Speicher
        output = BytesIO()
        workbook = xlsxwriter.Workbook(output)
        
        # Formatierungen
        header_format = workbook.add_format({
            'bold': True,
            'bg_color': '#4CAF50',
            'font_color': 'white',
            'border': 1
        })
        
        date_format = workbook.add_format({'num_format': 'dd.mm.yyyy hh:mm'})
        
        # Sheet 1: Übersicht
        overview_sheet = workbook.add_worksheet('Übersicht')
        
        # Header
        headers = ['Ressourcen-Typ', 'Gesamt', 'Verfügbar', 'Zugewiesen', 'Quarantäne', 'Test', 'Produktion']
        for col, header in enumerate(headers):
            overview_sheet.write(0, col, header, header_format)
        
        # Daten
        cur.execute("""
            SELECT 
                resource_type,
                COUNT(*) as total,
                COUNT(CASE WHEN status = 'available' THEN 1 END) as available,
                COUNT(CASE WHEN status = 'allocated' THEN 1 END) as allocated,
                COUNT(CASE WHEN status = 'quarantined' THEN 1 END) as quarantined,
                COUNT(CASE WHEN is_test = true THEN 1 END) as test,
                COUNT(CASE WHEN is_test = false THEN 1 END) as production
            FROM resource_pools
            GROUP BY resource_type
            ORDER BY resource_type
        """)
        
        row = 1
        for data in cur.fetchall():
            for col, value in enumerate(data):
                overview_sheet.write(row, col, value)
            row += 1
        
        # Sheet 2: Detailliste
        detail_sheet = workbook.add_worksheet('Detailliste')
        
        # Header
        headers = ['Typ', 'Wert', 'Status', 'Test', 'Kunde', 'Lizenz', 'Zugewiesen am', 'Zugewiesen von']
        for col, header in enumerate(headers):
            detail_sheet.write(0, col, header, header_format)
        
        # Daten
        cur.execute("""
            SELECT 
                rp.resource_type,
                rp.resource_value,
                rp.status,
                rp.is_test,
                c.name as customer_name,
                l.license_key,
                rp.status_changed_at,
                rp.status_changed_by
            FROM resource_pools rp
            LEFT JOIN licenses l ON rp.allocated_to_license = l.id
            LEFT JOIN customers c ON l.customer_id = c.id
            ORDER BY rp.resource_type, rp.resource_value
        """)
        
        row = 1
        for data in cur.fetchall():
            for col, value in enumerate(data):
                if col == 6 and value:  # Datum
                    detail_sheet.write_datetime(row, col, value, date_format)
                else:
                    detail_sheet.write(row, col, value if value is not None else '')
            row += 1
        
        # Spaltenbreiten anpassen
        overview_sheet.set_column('A:A', 20)
        overview_sheet.set_column('B:G', 12)
        
        detail_sheet.set_column('A:A', 15)
        detail_sheet.set_column('B:B', 30)
        detail_sheet.set_column('C:D', 12)
        detail_sheet.set_column('E:F', 25)
        detail_sheet.set_column('G:H', 20)
        
        workbook.close()
        output.seek(0)
        
        # Sende Datei
        filename = f"ressourcen_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
        return send_file(
            output,
            mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
            as_attachment=True,
            download_name=filename
        )
        
    except Exception as e:
        logging.error(f"Fehler beim Generieren des Reports: {str(e)}")
        flash('Fehler beim Generieren des Reports!', 'error')
        return redirect(url_for('resources.resources'))
    finally:
        cur.close()
        conn.close()