from flask import Blueprint, render_template, request, redirect, url_for, flash, jsonify
from controllers.auth_controller import login_required, admin_required
from models.people_model import PeopleModel
from models.project_model import ProjectModel
from models.report_model import ReportModel
from models.temperament_model import TemperamentModel
from utils.i18n import t

people_bp = Blueprint('people', __name__)

@people_bp.route('/')
@login_required
def index():
    peoples = PeopleModel.get_all_people()
    return render_template('peoples/index.html', peoples=peoples)

@people_bp.route('/create', methods=['GET', 'POST'])
@login_required
@admin_required
def create():
    if request.method == 'POST':
        name = request.form.get('name')
        project_id = request.form.get('project_id') or None
        phone = request.form.get('phone')
        email = request.form.get('email')
        
        if not name or not email:
            flash(t('messages.name_email_required', 'Name and email are required'), 'error')
            return render_template('peoples/create.html', projects=ProjectModel.get_all_projects())
        
        PeopleModel.create_person(name, project_id, phone, email)
        flash(t('messages.person_created', 'Person created successfully!'), 'success')
        return redirect(url_for('people.index'))
    
    projects = ProjectModel.get_all_projects()
    return render_template('peoples/create.html', projects=projects)

@people_bp.route('/edit/<int:person_id>', methods=['GET', 'POST'])
@login_required
@admin_required
def edit(person_id):
    person = PeopleModel.get_person_by_id(person_id)
    if not person:
        flash(t('messages.person_not_found', 'Person not found'), 'error')
        return redirect(url_for('people.index'))
    
    if request.method == 'POST':
        name = request.form.get('name')
        project_id = request.form.get('project_id') or None
        phone = request.form.get('phone')
        email = request.form.get('email')
        
        if not name or not email:
            flash(t('messages.name_email_required', 'Name and email are required'), 'error')
            return render_template('peoples/edit.html', person=person, projects=ProjectModel.get_all_projects())
        
        PeopleModel.update_person(person_id, name, project_id, phone, email)
        flash(t('messages.person_updated', 'Person updated successfully!'), 'success')
        return redirect(url_for('people.index'))
    
    projects = ProjectModel.get_all_projects()
    return render_template('peoples/edit.html', person=person, projects=projects)

@people_bp.route('/delete/<int:person_id>', methods=['POST'])
@login_required
@admin_required
def delete(person_id):
    person = PeopleModel.get_person_by_id(person_id)
    if not person:
        return jsonify({'error': t('messages.person_not_found', 'Person not found')}), 404

    # Check if person has answers
    answers_count = PeopleModel.get_person_answers_count(person_id)

    # Get confirmation from request
    force_delete = request.json.get('force_delete', False) if request.is_json else False

    if answers_count > 0 and not force_delete:
        # Return warning - requires confirmation
        return jsonify({
            'requires_confirmation': True,
            'answers_count': answers_count,
            'message': t('messages.person_has_answers', 'This person has {count} survey responses. Deleting will remove all their data.').format(count=answers_count)
        })

    # Proceed with deletion
    try:
        if answers_count > 0:
            PeopleModel.delete_person_with_answers(person_id)
        else:
            PeopleModel.delete_person(person_id)

        return jsonify({
            'success': True,
            'message': t('messages.person_deleted', 'Person deleted successfully!')
        })
    except Exception as e:
        return jsonify({'error': str(e)}), 500

@people_bp.route('/history/<int:person_id>')
@login_required
def history(person_id):
    """View person's complete history with all surveys and results"""
    from models.database import execute_query
    from models.recommendation_model import RecommendationModel

    person = PeopleModel.get_person_by_id(person_id)
    if not person:
        flash(t('messages.person_not_found', 'Person not found'), 'error')
        return redirect(url_for('people.index'))

    # Get all projects this person has participated in
    projects_query = """
        SELECT DISTINCT p.id, p.name, p.slug, p.start_date, p.end_date,
               COUNT(DISTINCT a.id) as answer_count,
               MIN(a.created_at) as first_answer,
               MAX(a.created_at) as last_answer
        FROM projects p
        INNER JOIN answers a ON a.project_id = p.id
        WHERE a.people_id = %s
        GROUP BY p.id, p.name, p.slug, p.start_date, p.end_date
        ORDER BY last_answer DESC
    """
    projects = execute_query(projects_query, (person_id,))

    # Get temperament data for this person
    temps = TemperamentModel.get_all_temperaments()
    preferred_order = ['Sanguine', 'Choleric', 'Melancholic', 'Phlegmatic']
    temps_sorted = sorted(temps, key=lambda t: preferred_order.index(t['name']) if t['name'] in preferred_order else 999)

    rows = ReportModel.get_person_temperament_counts(person_id)
    score_map = { r['temperament_id']: r['cnt'] for r in rows }
    total = sum(score_map.values()) or 1

    # Build ordered arrays for chart
    labels = [t['name'] for t in temps_sorted]
    colors = [t['color'] for t in temps_sorted]
    scores = [score_map.get(t['id'], 0) for t in temps_sorted]
    percents = [round((s/total)*100) for s in scores]

    # Get recommendation for this person
    recommendation = ReportModel.find_matching_recommendation(person_id)

    # Get total answer count
    total_answers = PeopleModel.get_person_answers_count(person_id)

    return render_template('peoples/history.html',
                           person=person,
                           projects=projects,
                           total_answers=total_answers,
                           labels=labels,
                           colors=colors,
                           scores=scores,
                           percents=percents,
                           temps=temps_sorted,
                           recommendation=recommendation)

@people_bp.route('/results/<int:person_id>')
@login_required
def results(person_id):
    person = PeopleModel.get_person_by_id(person_id)
    if not person:
        flash(t('messages.person_not_found', 'Person not found'), 'error')
        return redirect(url_for('people.index'))

    temps = TemperamentModel.get_all_temperaments()
    preferred_order = ['Sanguine', 'Choleric', 'Melancholic', 'Phlegmatic']
    temps_sorted = sorted(temps, key=lambda t: preferred_order.index(t['name']) if t['name'] in preferred_order else 999)

    rows = ReportModel.get_person_temperament_counts(person_id)
    # Map temperament_id -> count
    score_map = { r['temperament_id']: r['cnt'] for r in rows }
    total = sum(score_map.values()) or 1

    # Build ordered arrays
    labels = [t['name'] for t in temps_sorted]
    colors = [t['color'] for t in temps_sorted]
    scores = [score_map.get(t['id'], 0) for t in temps_sorted]
    percents = [round((s/total)*100) for s in scores]

    return render_template('peoples/results.html',
                           person=person,
                           labels=labels,
                           colors=colors,
                           scores=scores,
                           percents=percents)
