"""
Dashboard routes - Main user dashboard
"""
from flask import Blueprint, render_template, redirect, url_for, flash, request, jsonify
from flask_login import login_required, current_user
from app import db
from app.models import User, Instance, UsageRecord
from datetime import datetime, timedelta
from sqlalchemy import func

dashboard_bp = Blueprint('dashboard', __name__)


@dashboard_bp.route('/')
@login_required
def index():
    """Main dashboard"""
    # Get user's instances
    instances = Instance.query.filter_by(user_id=current_user.id).all()

    # Calculate usage stats
    today = datetime.utcnow().date()
    thirty_days_ago = today - timedelta(days=30)

    usage_stats = db.session.query(
        func.sum(UsageRecord.total_messages).label('messages'),
        func.sum(UsageRecord.total_tokens).label('tokens'),
        func.sum(UsageRecord.total_canvas_pages).label('pages')
    ).filter(
        UsageRecord.user_id == current_user.id,
        UsageRecord.date >= thirty_days_ago
    ).first()

    # Get recent activity
    recent_activity = UsageRecord.query.filter_by(
        user_id=current_user.id
    ).order_by(UsageRecord.created_at.desc()).limit(10).all()

    # Check subscription status
    is_subscribed = current_user.is_subscribed()
    max_instances = current_user.get_max_instances()

    return render_template('dashboard/index.html',
                         instances=instances,
                         usage_stats=usage_stats,
                         recent_activity=recent_activity,
                         is_subscribed=is_subscribed,
                         max_instances=max_instances,
                         can_create_instance=len(instances) < max_instances)


@dashboard_bp.route('/settings')
@login_required
def settings():
    """User settings"""
    return render_template('dashboard/settings.html')


@dashboard_bp.route('/usage')
@login_required
def usage():
    """Usage statistics page"""
    # Get last 90 days of usage
    ninety_days_ago = datetime.utcnow().date() - timedelta(days=90)

    usage_history = db.session.query(
        UsageRecord.date,
        func.sum(UsageRecord.total_messages).label('messages'),
        func.sum(UsageRecord.total_tokens).label('tokens'),
        func.sum(UsageRecord.total_minutes_active).label('minutes')
    ).filter(
        UsageRecord.user_id == current_user.id,
        UsageRecord.date >= ninety_days_ago
    ).group_by(UsageRecord.date).order_by(UsageRecord.date).all()

    # Calculate totals
    total_messages = sum(row.messages or 0 for row in usage_history)
    total_tokens = sum(row.tokens or 0 for row in usage_history)
    total_minutes = sum(row.minutes or 0 for row in usage_history)

    return render_template('dashboard/usage.html',
                         usage_history=usage_history,
                         total_messages=total_messages,
                         total_tokens=total_tokens,
                         total_minutes=total_minutes)


@dashboard_bp.route('/profile', methods=['GET', 'POST'])
@login_required
def profile():
    """User profile settings"""
    if request.method == 'POST':
        # Update user profile
        current_user.full_name = request.form.get('full_name')
        current_user.personal_email = request.form.get('personal_email')
        current_user.email_preference = request.form.get('email_preference', 'primary')

        db.session.commit()
        flash('Profile updated successfully!', 'success')
        return redirect(url_for('dashboard.profile'))

    return render_template('dashboard/profile.html')


# Instance management routes

@dashboard_bp.route('/instances')
@login_required
def instances():
    """List all instances"""
    instances = Instance.query.filter_by(user_id=current_user.id).all()
    return render_template('dashboard/instances.html', instances=instances)


@dashboard_bp.route('/instances/new', methods=['GET', 'POST'])
@login_required
def new_instance():
    """Create new instance"""
    # Check if user can create more instances
    instance_count = Instance.query.filter_by(user_id=current_user.id).count()
    max_instances = current_user.get_max_instances()

    if instance_count >= max_instances:
        flash(f'You have reached your instance limit ({max_instances}). '
              f'Upgrade your plan to create more instances.', 'error')
        return redirect(url_for('dashboard.index'))

    if request.method == 'POST':
        name = request.form.get('name')
        description = request.form.get('description', '')

        if not name:
            flash('Instance name is required.', 'error')
            return render_template('instances/new.html')

        # Generate instance ID and subdomain
        instance_id = Instance.generate_instance_id()
        subdomain = Instance.generate_subdomain(name)

        # Get next available port
        last_instance = Instance.query.order_by(Instance.port.desc()).first()
        port = (last_instance.port + 1) if last_instance else 4500

        # Create instance
        instance = Instance(
            instance_id=instance_id,
            user_id=current_user.id,
            name=name,
            subdomain=subdomain,
            description=description,
            port=port,
            status='provisioning'
        )

        db.session.add(instance)
        db.session.commit()

        flash(f'Instance "{name}" created successfully!', 'success')
        return redirect(url_for('dashboard.manage_instance', instance_id=instance.id))

    return render_template('instances/new.html')


@dashboard_bp.route('/instances/<int:instance_id>')
@login_required
def manage_instance(instance_id):
    """Manage specific instance"""
    instance = Instance.query.get_or_404(instance_id)

    # Verify ownership
    if instance.user_id != current_user.id:
        flash('You do not have permission to access this instance.', 'error')
        return redirect(url_for('dashboard.instances'))

    # Get instance usage
    thirty_days_ago = datetime.utcnow().date() - timedelta(days=30)
    usage = db.session.query(
        func.sum(UsageRecord.total_messages).label('messages'),
        func.sum(UsageRecord.total_tokens).label('tokens')
    ).filter(
        UsageRecord.instance_id == instance.id,
        UsageRecord.date >= thirty_days_ago
    ).first()

    return render_template('instances/manage.html',
                         instance=instance,
                         usage=usage)


@dashboard_bp.route('/instances/<int:instance_id>/edit', methods=['GET', 'POST'])
@login_required
def edit_instance(instance_id):
    """Edit instance configuration"""
    instance = Instance.query.get_or_404(instance_id)

    if instance.user_id != current_user.id:
        flash('Permission denied.', 'error')
        return redirect(url_for('dashboard.instances'))

    if request.method == 'POST':
        instance.name = request.form.get('name')
        instance.description = request.form.get('description')
        instance.agent_persona = request.form.get('agent_persona', 'jarvis')
        instance.voice_provider = request.form.get('voice_provider', 'supertonic')
        instance.llm_provider = request.form.get('llm_provider', 'anthropic')

        # Feature toggles
        instance.enable_canvas = request.form.get('enable_canvas') == 'on'
        instance.enable_3d_ui = request.form.get('enable_3d_ui') == 'on'
        instance.enable_music_generation = request.form.get('enable_music_generation') == 'on'

        db.session.commit()
        flash('Instance updated successfully!', 'success')
        return redirect(url_for('dashboard.manage_instance', instance_id=instance.id))

    return render_template('instances/edit.html', instance=instance)


@dashboard_bp.route('/instances/<int:instance_id>/delete', methods=['POST'])
@login_required
def delete_instance(instance_id):
    """Delete instance"""
    instance = Instance.query.get_or_404(instance_id)

    if instance.user_id != current_user.id:
        return jsonify({'error': 'Permission denied'}), 403

    db.session.delete(instance)
    db.session.commit()

    flash('Instance deleted successfully.', 'success')
    return redirect(url_for('dashboard.instances'))


@dashboard_bp.route('/instances/<int:instance_id>/start', methods=['POST'])
@login_required
def start_instance(instance_id):
    """Start instance"""
    instance = Instance.query.get_or_404(instance_id)

    if instance.user_id != current_user.id:
        return jsonify({'error': 'Permission denied'}), 403

    # TODO: Implement instance startup logic
    instance.status = 'running'
    db.session.commit()

    return jsonify({'status': 'success', 'instance_url': instance.get_url()})


@dashboard_bp.route('/instances/<int:instance_id>/stop', methods=['POST'])
@login_required
def stop_instance(instance_id):
    """Stop instance"""
    instance = Instance.query.get_or_404(instance_id)

    if instance.user_id != current_user.id:
        return jsonify({'error': 'Permission denied'}), 403

    # TODO: Implement instance shutdown logic
    instance.status = 'stopped'
    db.session.commit()

    return jsonify({'status': 'success'})


@dashboard_bp.route('/instances/<int:instance_id>/launch')
@login_required
def launch_instance(instance_id):
    """Launch instance in new tab"""
    instance = Instance.query.get_or_404(instance_id)

    if instance.user_id != current_user.id:
        flash('Permission denied.', 'error')
        return redirect(url_for('dashboard.instances'))

    if instance.status != 'running':
        flash('Instance is not running. Please start it first.', 'error')
        return redirect(url_for('dashboard.manage_instance', instance_id=instance.id))

    # Redirect to instance URL
    instance_url = f"http{'s' if request.is_secure else ''}://{instance.get_url()}"
    return redirect(instance_url)