# Routes for Lead Management
from flask import render_template, request, jsonify, redirect, url_for, flash
from auth.decorators import login_required
from flask import session as flask_session
from . import leads_bp
from .services import LeadService
from .repositories import LeadRepository
from db import get_db_connection
from uuid import UUID
import traceback

# Service will be initialized per request
lead_repository = None
lead_service = None

def get_lead_service():
    """Get or create lead service instance"""
    global lead_repository, lead_service
    if lead_service is None:
        lead_repository = LeadRepository(get_db_connection)  # Pass the function, not call it
        lead_service = LeadService(lead_repository)
    return lead_service

# HTML Routes
@leads_bp.route('/management')
@login_required
def lead_management():
    """Lead Management Dashboard"""
    try:
        # Get current user
        current_user = flask_session.get('username', 'System')
        other_user = 'w@rh@mm3r' if current_user == 'rac00n' else 'rac00n'
        
        # Initialize defaults
        total_institutions = 0
        total_contacts = 0
        my_entries = 0
        other_entries = 0
        activities = []
        
        with get_db_connection() as conn:
            cur = conn.cursor()
            
            # Get statistics
            cur.execute("SELECT COUNT(*) FROM lead_institutions")
            result = cur.fetchone()
            if result:
                total_institutions = result[0]
            
            cur.execute("SELECT COUNT(*) FROM lead_contacts")
            result = cur.fetchone()
            if result:
                total_contacts = result[0]
            
            # Count entries by current user
            cur.execute("""
                SELECT COUNT(*) FROM audit_log 
                WHERE username = %s 
                AND entity_type IN ('lead_institution', 'lead_contact')
                AND action = 'CREATE'
            """, (current_user,))
            result = cur.fetchone()
            if result:
                my_entries = result[0]
            
            # Count entries by other user
            cur.execute("""
                SELECT COUNT(*) FROM audit_log 
                WHERE username = %s 
                AND entity_type IN ('lead_institution', 'lead_contact')
                AND action = 'CREATE'
            """, (other_user,))
            result = cur.fetchone()
            if result:
                other_entries = result[0]
            
            # Get recent activities
            cur.execute("""
                SELECT timestamp, username, action, entity_type, additional_info
                FROM audit_log
                WHERE entity_type IN ('lead_institution', 'lead_contact')
                ORDER BY timestamp DESC
                LIMIT 10
            """)
            rows = cur.fetchall()
            if rows:
                for row in rows:
                    activities.append({
                        'timestamp': row[0],
                        'username': row[1],
                        'action': row[2],
                        'entity_type': row[3].replace('lead_', ''),
                        'additional_info': row[4]
                    })
            
            cur.close()
        
        return render_template('leads/lead_management.html',
                             total_institutions=total_institutions,
                             total_contacts=total_contacts,
                             my_entries=my_entries,
                             other_entries=other_entries,
                             other_user=other_user,
                             current_user=current_user,
                             recent_activities=activities)
    except Exception as e:
        import traceback
        print(f"Error in lead_management: {str(e)}")
        print(traceback.format_exc())
        flash(f'Fehler beim Laden des Dashboards: {str(e)}', 'error')
        current_user = flask_session.get('username', 'System')
        return render_template('leads/lead_management.html',
                             total_institutions=0,
                             total_contacts=0,
                             my_entries=0,
                             other_entries=0,
                             other_user='',
                             current_user=current_user,
                             recent_activities=[])

@leads_bp.route('/')
@login_required
def institutions():
    """List all institutions"""
    try:
        institutions = get_lead_service().list_institutions()
        return render_template('leads/institutions.html', institutions=institutions)
    except Exception as e:
        flash(f'Fehler beim Laden der Institutionen: {str(e)}', 'error')
        return render_template('leads/institutions.html', institutions=[])

@leads_bp.route('/institution/add', methods=['POST'])
@login_required
def add_institution():
    """Add new institution from form"""
    try:
        name = request.form.get('name')
        if not name:
            flash('Name ist erforderlich', 'error')
            return redirect(url_for('leads.lead_management'))
        
        # Add institution
        get_lead_service().create_institution(name, flask_session.get('username', 'System'))
        flash(f'Institution "{name}" wurde erfolgreich hinzugefügt', 'success')
    except Exception as e:
        flash(f'Fehler beim Hinzufügen der Institution: {str(e)}', 'error')
    
    return redirect(url_for('leads.lead_management'))

@leads_bp.route('/institution/<uuid:institution_id>')
@login_required
def institution_detail(institution_id):
    """Show institution with all contacts"""
    try:
        institution = lead_repository.get_institution_by_id(institution_id)
        if not institution:
            flash('Institution nicht gefunden', 'error')
            return redirect(url_for('leads.institutions'))
        
        contacts = get_lead_service().list_contacts_by_institution(institution_id)
        return render_template('leads/institution_detail.html', 
                             institution=institution, 
                             contacts=contacts)
    except Exception as e:
        flash(f'Fehler beim Laden der Institution: {str(e)}', 'error')
        return redirect(url_for('leads.institutions'))

@leads_bp.route('/contact/<uuid:contact_id>')
@login_required
def contact_detail(contact_id):
    """Show contact details with notes"""
    try:
        contact = get_lead_service().get_contact_details(contact_id)
        return render_template('leads/contact_detail.html', contact=contact)
    except Exception as e:
        flash(f'Fehler beim Laden des Kontakts: {str(e)}', 'error')
        return redirect(url_for('leads.institutions'))

@leads_bp.route('/contacts')
@login_required
def all_contacts():
    """Show all contacts across all institutions"""
    try:
        contacts = get_lead_service().list_all_contacts()
        return render_template('leads/all_contacts.html', contacts=contacts)
    except Exception as e:
        flash(f'Fehler beim Laden der Kontakte: {str(e)}', 'error')
        return render_template('leads/all_contacts.html', contacts=[])

# API Routes
@leads_bp.route('/api/institutions', methods=['POST'])
@login_required
def create_institution():
    """Create new institution"""
    try:
        data = request.get_json()
        institution = get_lead_service().create_institution(
            data['name'], 
            flask_session.get('username')
        )
        return jsonify({'success': True, 'institution': institution})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/institutions/<uuid:institution_id>', methods=['PUT'])
@login_required
def update_institution(institution_id):
    """Update institution"""
    try:
        data = request.get_json()
        institution = get_lead_service().update_institution(
            institution_id,
            data['name'], 
            flask_session.get('username')
        )
        return jsonify({'success': True, 'institution': institution})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/contacts', methods=['POST'])
@login_required
def create_contact():
    """Create new contact"""
    try:
        data = request.get_json()
        contact = get_lead_service().create_contact(data, flask_session.get('username'))
        return jsonify({'success': True, 'contact': contact})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/contacts/<uuid:contact_id>', methods=['PUT'])
@login_required
def update_contact(contact_id):
    """Update contact"""
    try:
        data = request.get_json()
        contact = get_lead_service().update_contact(
            contact_id, 
            data, 
            flask_session.get('username')
        )
        return jsonify({'success': True, 'contact': contact})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/contacts/<uuid:contact_id>/phones', methods=['POST'])
@login_required
def add_phone(contact_id):
    """Add phone to contact"""
    try:
        data = request.get_json()
        detail = get_lead_service().add_phone(
            contact_id,
            data['phone_number'],
            data.get('phone_type'),
            flask_session.get('username')
        )
        return jsonify({'success': True, 'detail': detail})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/contacts/<uuid:contact_id>/emails', methods=['POST'])
@login_required
def add_email(contact_id):
    """Add email to contact"""
    try:
        data = request.get_json()
        detail = get_lead_service().add_email(
            contact_id,
            data['email'],
            data.get('email_type'),
            flask_session.get('username')
        )
        return jsonify({'success': True, 'detail': detail})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/details/<uuid:detail_id>', methods=['PUT'])
@login_required
def update_detail(detail_id):
    """Update contact detail (phone/email)"""
    try:
        data = request.get_json()
        detail = get_lead_service().update_contact_detail(
            detail_id,
            data['detail_value'],
            data.get('detail_label'),
            flask_session.get('username')
        )
        return jsonify({'success': True, 'detail': detail})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/details/<uuid:detail_id>', methods=['DELETE'])
@login_required
def delete_detail(detail_id):
    """Delete contact detail"""
    try:
        success = get_lead_service().delete_contact_detail(
            detail_id,
            flask_session.get('username')
        )
        return jsonify({'success': success})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/contacts/<uuid:contact_id>/notes', methods=['POST'])
@login_required
def add_note(contact_id):
    """Add note to contact"""
    try:
        data = request.get_json()
        note = get_lead_service().add_note(
            contact_id,
            data['note_text'],
            flask_session.get('username')
        )
        return jsonify({'success': True, 'note': note})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/notes/<uuid:note_id>', methods=['PUT'])
@login_required
def update_note(note_id):
    """Update note"""
    try:
        data = request.get_json()
        note = get_lead_service().update_note(
            note_id,
            data['note_text'],
            flask_session.get('username')
        )
        return jsonify({'success': True, 'note': note})
    except ValueError as e:
        return jsonify({'success': False, 'error': str(e)}), 400
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500

@leads_bp.route('/api/notes/<uuid:note_id>', methods=['DELETE'])
@login_required
def delete_note(note_id):
    """Delete note"""
    try:
        success = get_lead_service().delete_note(
            note_id,
            flask_session.get('username')
        )
        return jsonify({'success': success})
    except Exception as e:
        return jsonify({'success': False, 'error': str(e)}), 500


# Export Routes
@leads_bp.route('/export')
@login_required
def export_leads():
    """Export leads data as Excel/CSV"""
    from utils.export import create_excel_export, create_csv_export
    
    try:
        conn = get_db_connection()
        cur = conn.cursor()
        
        # Query institutions with contact counts
        cur.execute("""
            SELECT 
                i.id,
                i.name,
                i.type,
                i.website,
                i.address,
                i.created_at,
                i.created_by,
                COUNT(DISTINCT c.id) as contact_count,
                COUNT(DISTINCT cd.id) as contact_detail_count,
                COUNT(DISTINCT n.id) as note_count
            FROM lead_institutions i
            LEFT JOIN lead_contacts c ON i.id = c.institution_id
            LEFT JOIN lead_contact_details cd ON c.id = cd.contact_id
            LEFT JOIN lead_notes n ON i.id = n.institution_id
            GROUP BY i.id, i.name, i.type, i.website, i.address, i.created_at, i.created_by
            ORDER BY i.name
        """)
        
        # Prepare data for export
        data = []
        columns = ['ID', 'Institution', 'Typ', 'Website', 'Adresse', 
                  'Erstellt am', 'Erstellt von', 'Anzahl Kontakte', 
                  'Anzahl Kontaktdetails', 'Anzahl Notizen']
        
        for row in cur.fetchall():
            data.append(list(row))
        
        # Check format parameter
        format_type = request.args.get('format', 'excel').lower()
        
        if format_type == 'csv':
            return create_csv_export(data, columns, 'leads')
        else:
            return create_excel_export(data, columns, 'leads')
            
    except Exception as e:
        flash(f'Fehler beim Export: {str(e)}', 'error')
        return redirect(url_for('leads.institutions'))
    finally:
        cur.close()
        conn.close()