# app/admin/routes.py
from flask import render_template, redirect, url_for, flash, request, jsonify
from flask_login import login_required, current_user
from app.admin import admin_bp
from app.admin.forms import *
from app.extensions import db
from app.models import *
from datetime import datetime, timedelta
from sqlalchemy import func, and_, or_
import json
import logging

# تنظیم لاگر
logger = logging.getLogger(__name__)

# ==================== توابع کمکی ====================

def send_notification(user_id, title, message, type='info'):
    """ارسال نوتیفیکیشن به کاربر"""
    try:
        from app.models import Notification
        notification = Notification(
            user_id=user_id,
            title=title,
            message=message,
            type=type,
            created_at=datetime.utcnow(),
            is_read=False
        )
        db.session.add(notification)
        db.session.commit()
        return True
    except Exception as e:
        logger.error(f"Error sending notification: {str(e)}")
        db.session.rollback()
        return False

def generate_check_number():
    """تولید شماره چک منحصر به فرد"""
    import random
    import string
    prefix = "CHK"
    random_digits = ''.join(random.choices(string.digits, k=8))
    return f"{prefix}{random_digits}"

# ==================== 0. داشبورد اصلی ادمین ====================
@admin_bp.route('/')
@admin_bp.route('/index')
@admin_bp.route('/dashboard')
@login_required
def index():
    """داشبورد اصلی مدیریت سیستم"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    try:
        # ========== آمار کلی سیستم ==========
        
        # آمار کاربران
        total_users = User.query.count()
        total_managers = User.query.filter_by(role='manager', is_active=True).count()
        total_employees = User.query.filter_by(role='employee', is_active=True).count()
        pending_manager_requests = User.query.filter_by(
            role='manager', 
            manager_request_status='pending'
        ).count()
        
        # آمار پروژه‌ها
        total_projects = Project.query.count()
        active_projects = Project.query.filter_by(status='active').count()
        completed_projects = Project.query.filter_by(status='completed').count()
        pending_projects = Project.query.filter_by(status='pending').count()
        
        # آمار قراردادها
        total_contracts = Contract.query.count()
        active_contracts = Contract.query.filter_by(is_active=True).count()
        
        # آمار مالی
        total_escrow_balance = db.session.query(func.sum(EscrowAccount.balance)).scalar() or 0
        total_deposited = db.session.query(func.sum(EscrowAccount.total_deposited)).scalar() or 0
        total_released = db.session.query(func.sum(EscrowAccount.total_released)).scalar() or 0
        
        # کمیسیون‌های سیستم
        pending_system_commissions = SystemCommission.query.filter_by(status='pending').count()
        total_system_commission_amount = db.session.query(
            func.sum(SystemCommission.system_commission_amount)
        ).filter_by(status='pending').scalar() or 0
        
        # ========== درخواست‌های نیازمند اقدام ==========
        
        pending_ads = AdvertisementRequest.query.filter_by(status='pending').count()
        pending_payment_requests = PaymentRequest.query.filter_by(status='pending').count()
        
        pending_releases = PaymentRelease.query.filter_by(
            status='pending', 
            admin_approved=False
        ).count()
        
        pending_smart_reports = SmartReport.query.filter_by(
            admin_verified=False
        ).count()
        
        # ========== وضعیت چک‌های الکترونیک ==========
        
        issued_checks = ElectronicCheck.query.filter_by(status='issued').count()
        active_checks = ElectronicCheck.query.filter_by(status='active').count()
        cancelled_checks = ElectronicCheck.query.filter_by(status='cancelled').count()
        total_checks_amount = db.session.query(func.sum(ElectronicCheck.amount)).scalar() or 0
        
        # ========== چک‌های بانکی ==========
        
        available_bank_checks = BankCheck.query.filter_by(status='available').count()
        allocated_bank_checks = BankCheck.query.filter_by(status='allocated').count()
        used_bank_checks = BankCheck.query.filter_by(status='used').count()
        
        # ========== فعالیت‌های اخیر ==========
        
        recent_deposits = Deposit.query.order_by(
            Deposit.created_at.desc()
        ).limit(10).all()
        
        recent_payment_requests = PaymentRequest.query.order_by(
            PaymentRequest.created_at.desc()
        ).limit(10).all()
        
        recent_checks = ElectronicCheck.query.order_by(
            ElectronicCheck.created_at.desc()
        ).limit(10).all()
        
        recent_users = User.query.order_by(
            User.created_at.desc()
        ).limit(10).all()
        
        # ========== گزارش روزانه ==========
        
        today = datetime.now().date()
        today_start = datetime.combine(today, datetime.min.time())
        today_end = datetime.combine(today, datetime.max.time())
        
        today_deposits = Deposit.query.filter(
            Deposit.created_at.between(today_start, today_end)
        ).all()
        today_deposits_count = len(today_deposits)
        today_deposits_amount = sum(d.amount for d in today_deposits) if today_deposits else 0
        
        today_payments = PaymentRequest.query.filter(
            PaymentRequest.paid_at.between(today_start, today_end)
        ).all()
        today_payments_count = len(today_payments)
        today_payments_amount = sum(p.amount for p in today_payments) if today_payments else 0
        
        today_registrations = User.query.filter(
            User.created_at.between(today_start, today_end)
        ).count()
        
        # ========== آمار ماه جاری ==========
        
        month_start = today.replace(day=1)
        
        month_deposits = Deposit.query.filter(
            Deposit.created_at >= month_start
        ).all()
        month_deposits_amount = sum(d.amount for d in month_deposits) if month_deposits else 0
        
        month_payments = PaymentRequest.query.filter(
            PaymentRequest.paid_at >= month_start
        ).all()
        month_payments_amount = sum(p.amount for p in month_payments) if month_payments else 0
        
        # ========== هشدارها و اعلان‌ها ==========
        
        alerts = []
        
        low_balance_escrows = EscrowAccount.query.filter(
            EscrowAccount.balance < 1000000
        ).count()
        if low_balance_escrows > 0:
            alerts.append({
                'type': 'warning',
                'message': f'{low_balance_escrows} صندوق امانی دارای موجودی کم هستند'
            })
        
        expiring_checks = ElectronicCheck.query.filter(
            ElectronicCheck.due_date <= datetime.now() + timedelta(days=7),
            ElectronicCheck.status == 'active'
        ).count()
        if expiring_checks > 0:
            alerts.append({
                'type': 'info',
                'message': f'{expiring_checks} چک الکترونیک در 7 روز آینده منقضی می‌شوند'
            })
        
        if pending_payment_requests > 5:
            alerts.append({
                'type': 'danger',
                'message': f'{pending_payment_requests} درخواست پرداخت در انتظار بررسی هستند'
            })
        
        # ========== روند مالی (برای نمودار) ==========
        
        financial_trend = []
        for i in range(7, 0, -1):
            date = today - timedelta(days=i)
            date_start = datetime.combine(date, datetime.min.time())
            date_end = datetime.combine(date, datetime.max.time())
            
            day_deposits = db.session.query(func.sum(Deposit.amount)).filter(
                Deposit.created_at.between(date_start, date_end)
            ).scalar() or 0
            
            day_payments = db.session.query(func.sum(PaymentRequest.amount)).filter(
                PaymentRequest.paid_at.between(date_start, date_end)
            ).scalar() or 0
            
            financial_trend.append({
                'date': date.strftime('%Y-%m-%d'),
                'deposits': float(day_deposits),
                'payments': float(day_payments)
            })
        
        check_status_data = {
            'issued': issued_checks,
            'active': active_checks,
            'cancelled': cancelled_checks
        }
        
        return render_template(
            'admin/index.html',
            # آمار کلی
            total_users=total_users,
            total_managers=total_managers,
            total_employees=total_employees,
            pending_manager_requests=pending_manager_requests,
            total_projects=total_projects,
            active_projects=active_projects,
            completed_projects=completed_projects,
            pending_projects=pending_projects,
            total_contracts=total_contracts,
            active_contracts=active_contracts,
            total_escrow_balance=total_escrow_balance,
            total_deposited=total_deposited,
            total_released=total_released,
            pending_system_commissions=pending_system_commissions,
            total_system_commission_amount=total_system_commission_amount,
            # درخواست‌های نیازمند اقدام
            pending_ads=pending_ads,
            pending_payment_requests=pending_payment_requests,
            pending_releases=pending_releases,
            pending_smart_reports=pending_smart_reports,
            # وضعیت چک‌ها
            issued_checks=issued_checks,
            active_checks=active_checks,
            cancelled_checks=cancelled_checks,
            total_checks_amount=total_checks_amount,
            available_bank_checks=available_bank_checks,
            allocated_bank_checks=allocated_bank_checks,
            used_bank_checks=used_bank_checks,
            # فعالیت‌های اخیر
            recent_deposits=recent_deposits,
            recent_payment_requests=recent_payment_requests,
            recent_checks=recent_checks,
            recent_users=recent_users,
            # گزارش روزانه
            today_deposits_count=today_deposits_count,
            today_deposits_amount=today_deposits_amount,
            today_payments_count=today_payments_count,
            today_payments_amount=today_payments_amount,
            today_registrations=today_registrations,
            # آمار ماه جاری
            month_deposits_amount=month_deposits_amount,
            month_payments_amount=month_payments_amount,
            # هشدارها
            alerts=alerts,
            # داده‌های نمودار
            financial_trend=financial_trend,
            check_status_data=check_status_data,
            now=datetime.now()
        )
    except Exception as e:
        logger.error(f"Error in admin dashboard: {str(e)}")
        flash('خطا در بارگذاری داشبورد', 'danger')
        # ارسال متغیرهای پیش‌فرض برای جلوگیری از خطا
        return render_template(
            'admin/index.html',
            total_users=0,
            total_managers=0,
            total_employees=0,
            pending_manager_requests=0,
            total_projects=0,
            active_projects=0,
            completed_projects=0,
            pending_projects=0,
            total_contracts=0,
            active_contracts=0,
            total_escrow_balance=0,
            total_deposited=0,
            total_released=0,
            pending_system_commissions=0,
            total_system_commission_amount=0,
            pending_ads=0,
            pending_payment_requests=0,
            pending_releases=0,
            pending_smart_reports=0,
            issued_checks=0,
            active_checks=0,
            cancelled_checks=0,
            total_checks_amount=0,
            available_bank_checks=0,
            allocated_bank_checks=0,
            used_bank_checks=0,
            recent_deposits=[],
            recent_payment_requests=[],
            recent_checks=[],
            recent_users=[],
            today_deposits_count=0,
            today_deposits_amount=0,
            today_payments_count=0,
            today_payments_amount=0,
            today_registrations=0,
            month_deposits_amount=0,
            month_payments_amount=0,
            alerts=[{'type': 'danger', 'message': str(e)}],
            financial_trend=[],
            check_status_data={'issued': 0, 'active': 0, 'cancelled': 0},
            now=datetime.now()
        )


# ==================== 1. مدیریت صندوق امانی ====================

@admin_bp.route('/escrow/create', methods=['GET', 'POST'])
@login_required
def create_escrow():
    """ایجاد صندوق امانی مرکزی توسط ادمین"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('admin.dashboard'))
    
    existing_escrow = EscrowAccount.query.first()
    if existing_escrow:
        flash('صندوق امانی قبلاً در سیستم ایجاد شده است.', 'warning')
        return redirect(url_for('admin.escrow_detail'))
    
    form = CreateEscrowForm()
    
    if form.validate_on_submit():
        try:
            escrow = EscrowAccount(
                bank_name=form.bank_name.data,
                bank_branch=form.bank_branch.data or '',
                account_number=form.account_number.data,
                shaba_number=form.shaba_number.data or '',
                card_number=form.card_number.data or '',
                balance=form.initial_balance.data or 0,
                total_deposited=0,
                total_released=0,
                total_fees=0,
                is_active=form.is_active.data,
                status='active',
                description=form.description.data,
                created_by=current_user.id
            )
            db.session.add(escrow)
            db.session.commit()
            
            managers = User.query.filter_by(role='manager', is_active=True).all()
            for manager in managers:
                send_notification(
                    manager.id,
                    'ایجاد صندوق امانی مرکزی',
                    f'صندوق امانی مرکزی با شماره حساب {escrow.account_number} در بانک {escrow.bank_name} ایجاد شد.',
                    'success'
                )
            
            flash(f'✅ صندوق امانی مرکزی با موفقیت ایجاد شد.', 'success')
            return redirect(url_for('admin.escrow_detail'))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error creating escrow: {str(e)}")
            flash(f'❌ خطا در ایجاد صندوق امانی: {str(e)}', 'danger')
    
    return render_template('admin/create_escrow.html', form=form)


@admin_bp.route('/escrow/detail')
@login_required
def escrow_detail():
    """نمایش جزئیات صندوق امانی مرکزی"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('admin.dashboard'))
    
    escrow = EscrowAccount.query.first()
    
    if not escrow:
        flash('صندوق امانی در سیستم ایجاد نشده است.', 'warning')
        return redirect(url_for('admin.create_escrow'))
    
    deposits = Deposit.query.filter_by(
        escrow_id=escrow.id
    ).order_by(Deposit.created_at.desc()).limit(20).all()
    
    transactions = EscrowTransaction.query.filter_by(
        escrow_id=escrow.id
    ).order_by(EscrowTransaction.created_at.desc()).limit(50).all()
    
    return render_template(
        'admin/escrow_detail.html',
        escrow=escrow,
        deposits=deposits,
        transactions=transactions
    )


@admin_bp.route('/escrow/edit', methods=['GET', 'POST'])
@login_required
def edit_escrow():
    """ویرایش صندوق امانی مرکزی"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('admin.dashboard'))
    
    escrow = EscrowAccount.query.first()
    
    if not escrow:
        flash('صندوق امانی در سیستم ایجاد نشده است.', 'warning')
        return redirect(url_for('admin.create_escrow'))
    
    form = EditEscrowForm(obj=escrow)
    
    if form.validate_on_submit():
        try:
            escrow.bank_name = form.bank_name.data
            escrow.bank_branch = form.bank_branch.data or ''
            escrow.account_number = form.account_number.data
            escrow.shaba_number = form.shaba_number.data or ''
            escrow.card_number = form.card_number.data or ''
            escrow.is_active = form.is_active.data
            escrow.description = form.description.data
            escrow.updated_at = datetime.utcnow()
            
            db.session.commit()
            flash('✅ اطلاعات صندوق امانی با موفقیت به‌روزرسانی شد.', 'success')
            return redirect(url_for('admin.escrow_detail'))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error updating escrow: {str(e)}")
            flash(f'❌ خطا در به‌روزرسانی: {str(e)}', 'danger')
    
    return render_template('admin/edit_escrow.html', form=form, escrow=escrow)


@admin_bp.route('/escrow/reports')
@login_required
def escrow_reports():
    """گزارشات صندوق امانی"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('admin.dashboard'))
    
    escrow = EscrowAccount.query.first()
    
    if not escrow:
        flash('صندوق امانی در سیستم ایجاد نشده است.', 'warning')
        return redirect(url_for('admin.create_escrow'))
    
    project_id = request.args.get('project_id', type=int)
    from_date = request.args.get('from_date')
    to_date = request.args.get('to_date')
    transaction_type = request.args.get('transaction_type')
    
    query = EscrowTransaction.query.filter_by(escrow_id=escrow.id)
    
    if project_id:
        query = query.filter_by(project_id=project_id)
    
    if from_date:
        try:
            from_date_obj = datetime.strptime(from_date, '%Y-%m-%d')
            query = query.filter(EscrowTransaction.created_at >= from_date_obj)
        except ValueError:
            pass
    
    if to_date:
        try:
            to_date_obj = datetime.strptime(to_date, '%Y-%m-%d')
            to_date_obj = to_date_obj + timedelta(days=1)
            query = query.filter(EscrowTransaction.created_at <= to_date_obj)
        except ValueError:
            pass
    
    if transaction_type:
        query = query.filter_by(transaction_type=transaction_type)
    
    transactions = query.order_by(EscrowTransaction.created_at.desc()).limit(100).all()
    
    total_deposits = escrow.total_deposited
    total_withdrawals = escrow.total_released
    total_fees = escrow.total_fees
    current_balance = escrow.balance
    
    projects = Project.query.order_by(Project.name).all()
    
    project_stats = []
    for project in projects:
        project_balance = escrow.get_project_balance(project.id)
        if project_balance != 0:
            project_stats.append({
                'project': project,
                'balance': project_balance,
                'balance_formatted': f"{project_balance:,.0f}",
                'deposits': escrow.get_deposits_total(project.id),
                'withdrawals': escrow.get_withdrawals_total(project.id)
            })
    
    return render_template(
        'admin/escrow_reports.html',
        escrow=escrow,
        transactions=transactions,
        total_deposits=total_deposits,
        total_withdrawals=total_withdrawals,
        total_fees=total_fees,
        current_balance=current_balance,
        projects=projects,
        project_stats=project_stats,
        selected_project=project_id,
        from_date=from_date,
        to_date=to_date,
        selected_type=transaction_type
    )

# ==================== 2. مدیریت تبلیغات ====================

@admin_bp.route('/advertisements')
@login_required
def advertisements():
    """مدیریت تبلیغات"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    pending_ads = AdvertisementRequest.query.filter_by(
        status='pending'
    ).order_by(AdvertisementRequest.created_at.desc()).all()
    
    approved_ads = AdvertisementRequest.query.filter_by(
        status='approved'
    ).order_by(AdvertisementRequest.created_at.desc()).all()
    
    rejected_ads = AdvertisementRequest.query.filter_by(
        status='rejected'
    ).order_by(AdvertisementRequest.created_at.desc()).all()
    
    return render_template('admin/advertisements.html', 
                         pending_ads=pending_ads,
                         approved_ads=approved_ads,
                         rejected_ads=rejected_ads)


@admin_bp.route('/advertisement/<int:ad_id>/approve', methods=['GET', 'POST'])
@login_required
def approve_advertisement(ad_id):
    """تایید یا رد تبلیغات"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    ad = AdvertisementRequest.query.get_or_404(ad_id)
    form = AdvertisementApproveForm()
    
    if form.validate_on_submit():
        try:
            ad.status = form.status.data
            ad.admin_note = form.note.data
            ad.approved_by = current_user.id
            ad.approved_at = datetime.utcnow()
            
            if form.status.data == 'approved':
                ad.start_date = datetime.utcnow()
                ad.end_date = datetime.utcnow() + timedelta(days=ad.duration_days)
                
                # ارسال نوتیفیکیشن به کاربر
                send_notification(
                    ad.user_id,
                    'تایید تبلیغ',
                    f'تبلیغ شما با عنوان "{ad.title}" تایید و فعال شد.',
                    'success'
                )
                flash('تبلیغ با موفقیت تایید و فعال شد', 'success')
            else:
                send_notification(
                    ad.user_id,
                    'رد تبلیغ',
                    f'تبلیغ شما با عنوان "{ad.title}" رد شد. دلیل: {form.note.data or "عدم تطابق با قوانین"}',
                    'danger'
                )
                flash('تبلیغ رد شد', 'warning')
            
            db.session.commit()
            return redirect(url_for('admin.advertisements'))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error approving advertisement: {str(e)}")
            flash(f'خطا در تایید تبلیغ: {str(e)}', 'danger')
    
    return render_template('admin/approve_advertisement.html', ad=ad, form=form)


@admin_bp.route('/advertisement/<int:ad_id>/delete', methods=['GET', 'POST'])
@login_required
def delete_advertisement(ad_id):
    """حذف تبلیغات"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    ad = AdvertisementRequest.query.get_or_404(ad_id)
    
    if ad.status == 'approved' and ad.end_date and ad.end_date > datetime.utcnow():
        flash('این تبلیغ هنوز فعال است و قابل حذف نمی‌باشد', 'danger')
        return redirect(url_for('admin.advertisements'))
    
    if request.method == 'POST':
        try:
            db.session.delete(ad)
            db.session.commit()
            flash('تبلیغ با موفقیت حذف شد', 'success')
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error deleting advertisement: {str(e)}")
            flash(f'خطا در حذف تبلیغ: {str(e)}', 'danger')
        return redirect(url_for('admin.advertisements'))
    
    return render_template('admin/delete_advertisement.html', ad=ad)


@admin_bp.route('/advertisement/<int:ad_id>/edit', methods=['GET', 'POST'])
@login_required
def edit_advertisement(ad_id):
    """ویرایش تبلیغات"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    ad = AdvertisementRequest.query.get_or_404(ad_id)
    form = AdvertisementEditForm(obj=ad)
    
    if form.validate_on_submit():
        try:
            ad.title = form.title.data
            ad.description = form.description.data
            ad.price = form.price.data
            ad.duration_days = form.duration_days.data
            ad.position = form.position.data
            
            if ad.status == 'approved':
                if form.start_date.data:
                    ad.start_date = form.start_date.data
                if form.end_date.data:
                    ad.end_date = form.end_date.data
            
            db.session.commit()
            flash('تبلیغ با موفقیت ویرایش شد', 'success')
            return redirect(url_for('admin.advertisements'))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error editing advertisement: {str(e)}")
            flash(f'خطا در ویرایش تبلیغ: {str(e)}', 'danger')
    
    return render_template('admin/edit_advertisement.html', ad=ad, form=form)


@admin_bp.route('/advertisement/<int:ad_id>/view')
@login_required
def view_advertisement(ad_id):
    """مشاهده جزئیات تبلیغ"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    ad = AdvertisementRequest.query.get_or_404(ad_id)
    return render_template('admin/view_advertisement.html', ad=ad)

# ==================== 3. مدیریت درخواست مدیران ====================

@admin_bp.route('/manager-requests')
@login_required
def manager_requests():
    """درخواست‌های ثبت نام مدیران"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    pending_requests = User.query.filter_by(
        role='manager', 
        manager_request_status='pending'
    ).all()
    
    approved_managers = User.query.filter_by(
        role='manager', 
        manager_request_status='approved', 
        is_active=True
    ).all()
    
    return render_template('admin/manager_requests.html', 
                         pending_requests=pending_requests,
                         approved_managers=approved_managers)


@admin_bp.route('/manager-request/<int:user_id>/approve', methods=['GET', 'POST'])
@login_required
def approve_manager_request(user_id):
    """تایید درخواست مدیر"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    user = User.query.get_or_404(user_id)
    form = ManagerApproveForm()
    
    if form.validate_on_submit():
        try:
            user.manager_request_status = form.status.data
            user.manager_request_note = form.note.data
            user.manager_approved_at = datetime.utcnow()
            user.manager_approved_by = current_user.id
            
            if form.status.data == 'approved':
                user.is_active = True
                user.is_verified = True
                send_notification(
                    user.id,
                    'تایید عضویت مدیر',
                    'عضویت شما به عنوان مدیر پروژه تایید شد. خوش آمدید!',
                    'success'
                )
                flash(f'مدیر {user.fullname} با موفقیت تایید شد', 'success')
            else:
                user.is_active = False
                send_notification(
                    user.id,
                    'رد درخواست مدیر',
                    f'درخواست عضویت شما به عنوان مدیر رد شد. دلیل: {form.note.data or "عدم احراز شرایط"}',
                    'danger'
                )
                flash(f'درخواست مدیر {user.fullname} رد شد', 'warning')
            
            db.session.commit()
            return redirect(url_for('admin.manager_requests'))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error approving manager: {str(e)}")
            flash(f'خطا در تایید مدیر: {str(e)}', 'danger')
    
    return render_template('admin/approve_manager.html', user=user, form=form)

# ==================== 4. مدیریت کاربران ====================

@admin_bp.route('/users')
@login_required
def users():
    """لیست تمام کاربران"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    role_filter = request.args.get('role', 'all')
    
    if role_filter == 'all':
        users = User.query.order_by(User.created_at.desc()).all()
    else:
        users = User.query.filter_by(role=role_filter).order_by(User.created_at.desc()).all()
    
    return render_template('admin/users.html', users=users, role_filter=role_filter)


@admin_bp.route('/user/<int:user_id>')
@login_required
def view_user(user_id):
    """مشاهده جزئیات کاربر"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    user = User.query.get_or_404(user_id)
    
    user_projects = []
    user_contracts = []
    user_payments = []
    user_reports = []
    
    if user.role == 'manager':
        user_projects = Project.query.filter_by(manager_id=user.id).all()
        user_contracts = Contract.query.filter_by(manager_id=user.id).all()
    elif user.role == 'employer':
        user_projects = Project.query.filter_by(employer_id=user.id).all()
        user_contracts = Contract.query.filter_by(employer_id=user.id).all()
    elif user.role == 'employee':
        user_reports = DailyReport.query.filter_by(user_id=user.id).all()
        user_payments = PaymentRequest.query.filter_by(user_id=user.id).all()
    
    stats = {
        'total_projects': len(user_projects),
        'total_contracts': len(user_contracts),
        'total_payments': len(user_payments),
        'total_reports': len(user_reports)
    }
    
    return render_template('admin/view_user.html', 
                         user=user,
                         projects=user_projects,
                         contracts=user_contracts,
                         payments=user_payments,
                         reports=user_reports,
                         stats=stats)


@admin_bp.route('/user/<int:user_id>/toggle_active', methods=['POST'])
@login_required
def toggle_user_active(user_id):
    """فعال/غیرفعال کردن کاربر"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    user = User.query.get_or_404(user_id)
    
    if user.id == current_user.id:
        flash('نمی‌توانید حساب کاربری خود را غیرفعال کنید', 'danger')
        return redirect(url_for('admin.users'))
    
    try:
        user.is_active = not user.is_active
        db.session.commit()
        
        status = 'فعال' if user.is_active else 'غیرفعال'
        
        send_notification(
            user.id,
            f'تغییر وضعیت حساب کاربری',
            f'حساب کاربری شما {status} شد.',
            'info'
        )
        
        flash(f'حساب کاربری {user.fullname} با موفقیت {status} شد', 'success')
    except Exception as e:
        db.session.rollback()
        logger.error(f"Error toggling user status: {str(e)}")
        flash(f'خطا در تغییر وضعیت: {str(e)}', 'danger')
    
    return redirect(url_for('admin.users'))

# ==================== 5. مدیریت چک‌های الکترونیک ====================

@admin_bp.route('/electronic-checks')
@login_required
def electronic_checks_list():
    """لیست چک‌های الکترونیک صادر شده"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    status_filter = request.args.get('status', '')
    project_id = request.args.get('project_id', '')
    
    query = ElectronicCheck.query
    
    if status_filter:
        query = query.filter(ElectronicCheck.status == status_filter)
    if project_id:
        query = query.filter(ElectronicCheck.project_id == project_id)
    
    checks = query.order_by(ElectronicCheck.created_at.desc()).all()
    projects = Project.query.filter_by(status='active').all()
    
    return render_template('admin/electronic_checks.html', 
                         checks=checks, 
                         projects=projects,
                         status_filter=status_filter,
                         project_id=project_id)


@admin_bp.route('/electronic-check/<int:check_id>/cancel', methods=['POST'])
@login_required
def cancel_electronic_check(check_id):
    """ابطال چک الکترونیک"""
    if current_user.role != 'admin':
        return jsonify({'error': 'دسترسی غیرمجاز'}), 403
    
    check = ElectronicCheck.query.get_or_404(check_id)
    data = request.get_json()
    reason = data.get('reason', '')
    
    if check.status not in ['issued', 'active']:
        return jsonify({'error': 'این چک قابل ابطال نیست'}), 400
    
    try:
        check.status = 'cancelled'
        
        transaction = CheckTransaction(
            check_id=check.id,
            transaction_type='cancel',
            amount=check.amount,
            before_status=check.status,
            after_status='cancelled',
            reason=reason,
            performed_by=current_user.id
        )
        db.session.add(transaction)
        db.session.commit()
        
        # ارسال نوتیفیکیشن به گیرنده
        if check.recipient_id:
            send_notification(
                check.recipient_id,
                'ابطال چک',
                f'چک شماره {check.check_number} به مبلغ {check.amount:,.0f} تومان ابطال شد.',
                'warning'
            )
        
        return jsonify({'success': True, 'message': 'چک با موفقیت ابطال شد'})
    except Exception as e:
        db.session.rollback()
        logger.error(f"Error canceling check: {str(e)}")
        return jsonify({'error': str(e)}), 500

# ==================== 6. مدیریت درخواست‌های پرداخت و آزادسازی ====================

@admin_bp.route('/payment-requests')
@login_required
def payment_requests_list():
    """لیست درخواست‌های پرداخت"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    pending_requests = PaymentRequest.query.filter_by(
        status='pending'
    ).order_by(PaymentRequest.created_at.desc()).all()
    
    approved_requests = PaymentRequest.query.filter_by(
        status='approved'
    ).order_by(PaymentRequest.created_at.desc()).all()
    
    paid_requests = PaymentRequest.query.filter_by(
        status='paid'
    ).order_by(PaymentRequest.paid_at.desc()).all()
    
    return render_template('admin/payment_requests.html',
                         pending_requests=pending_requests,
                         approved_requests=approved_requests,
                         paid_requests=paid_requests)


@admin_bp.route('/payment-request/<int:request_id>/process', methods=['GET', 'POST'])
@login_required
def process_payment_request(request_id):
    """پردازش درخواست پرداخت و صدور چک الکترونیک"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    payment_request = PaymentRequest.query.get_or_404(request_id)
    contract = payment_request.contract
    employee = contract.user
    
    # محاسبه کمیسیون‌ها
    system_commission = payment_request.amount * 0.10
    manager_commission = payment_request.amount * 0.05
    net_amount = payment_request.amount - system_commission - manager_commission
    
    if request.method == 'POST':
        bank_name = request.form.get('bank_name')
        due_days = int(request.form.get('due_days', 30))
        
        try:
            payment_request.admin_approved = True
            payment_request.admin_approved_at = datetime.utcnow()
            payment_request.admin_approved_by = current_user.id
            
            if payment_request.check_approvals():
                payment_request.status = 'approved'
                
                # ایجاد چک الکترونیک
                check = ElectronicCheck(
                    payment_request_id=payment_request.id,
                    amount=net_amount,
                    recipient_name=employee.fullname,
                    recipient_phone=employee.phone,
                    recipient_national_code=employee.national_code,
                    issue_date=datetime.utcnow(),
                    due_date=datetime.utcnow() + timedelta(days=due_days),
                    bank_name=bank_name,
                    description=f"پرداخت بابت قرارداد {contract.id} - درخواست {payment_request.request_number}",
                    issued_by=current_user.id,
                    status='issued'
                )
                check.generate_check_number()
                db.session.add(check)
                
                payment_request.electronic_check_id = check.id
                
                # بروزرسانی قرارداد
                contract.paid_amount += payment_request.amount
                contract.remaining_amount = contract.total_amount - contract.paid_amount
                
                if payment_request.installment:
                    payment_request.installment.status = 'paid'
                    payment_request.installment.paid_amount = payment_request.amount
                    payment_request.installment.paid_at = datetime.utcnow()
                
                # ثبت کمیسیون سیستم
                system_commission_entry = SystemCommission(
                    contract_id=contract.id,
                    project_id=contract.project_id,
                    deposit_id=None,
                    total_amount=payment_request.amount,
                    system_commission_amount=system_commission,
                    manager_commission_amount=manager_commission,
                    manager_id=contract.project.manager_id,
                    status='pending'
                )
                db.session.add(system_commission_entry)
                
                db.session.commit()
                
                # ارسال نوتیفیکیشن به کارمند
                send_notification(
                    employee.id,
                    'صدور چک الکترونیک',
                    f'چک به شماره {check.check_number} به مبلغ {net_amount:,.0f} تومان صادر شد.',
                    'success'
                )
                
                flash(f'چک الکترونیک به شماره {check.check_number} با موفقیت صادر شد', 'success')
            else:
                db.session.commit()
                flash('منتظر تایید مدیر و کارفرما هستید', 'warning')
            
            return redirect(url_for('admin.payment_requests_list'))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error processing payment request: {str(e)}")
            flash(f'خطا در صدور چک: {str(e)}', 'danger')
    
    return render_template('admin/process_payment_request.html',
                         payment_request=payment_request,
                         contract=contract,
                         employee=employee,
                         system_commission=system_commission,
                         manager_commission=manager_commission,
                         net_amount=net_amount)


@admin_bp.route('/payment-releases')
@login_required
def payment_releases():
    """لیست درخواست‌های آزادسازی وجه"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    pending_releases = PaymentRelease.query.filter_by(
        status='pending', 
        admin_approved=False
    ).all()
    
    approved_releases = PaymentRelease.query.filter_by(
        admin_approved=True
    ).all()
    
    return render_template('admin/payment_releases.html', 
                         pending_releases=pending_releases,
                         approved_releases=approved_releases)


@admin_bp.route('/payment-release/<int:release_id>/process', methods=['GET', 'POST'])
@login_required
def process_payment_release(release_id):
    """پردازش درخواست آزادسازی و صدور چک الکترونیک"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    release = PaymentRelease.query.get_or_404(release_id)
    form = PaymentReleaseProcessForm()
    
    system_commission = release.amount * 0.1
    net_amount = release.amount - system_commission
    
    if form.validate_on_submit():
        try:
            release.admin_approved = True
            release.admin_approved_at = datetime.utcnow()
            release.status = 'approved'
            
            # ایجاد چک الکترونیک
            check = ElectronicCheck(
                amount=net_amount,
                recipient_name=release.release_employee.fullname,
                recipient_phone=release.release_employee.phone,
                due_date=datetime.utcnow() + timedelta(days=form.due_days.data),
                bank_name=form.bank_name.data,
                description=f"آزادسازی وجه بابت قرارداد {release.contract_id} - کمیسیون سیستم: {system_commission:,.0f} تومان",
                status='issued'
            )
            check.generate_check_number()
            db.session.add(check)
            
            # ثبت کمیسیون سیستم
            commission = SystemCommission(
                contract_id=release.contract_id,
                project_id=release.release_deposit.project_id,
                deposit_id=release.deposit_id,
                total_amount=release.amount,
                system_commission_amount=system_commission,
                manager_commission_amount=release.amount * 0.05,
                manager_id=release.release_contract.project.manager_id,
                status='pending'
            )
            db.session.add(commission)
            
            release.electronic_check_id = check.id
            
            # ثبت تراکنش
            transaction = CheckTransaction(
                check_id=check.id,
                transaction_type='issue',
                amount=net_amount,
                before_status='pending',
                after_status='issued',
                reason='تایید نهایی و صدور چک',
                performed_by=current_user.id
            )
            db.session.add(transaction)
            
            db.session.commit()
            
            # ارسال نوتیفیکیشن به گیرنده
            send_notification(
                release.release_employee.id,
                'صدور چک آزادسازی',
                f'چک به شماره {check.check_number} به مبلغ {net_amount:,.0f} تومان صادر شد.',
                'success'
            )
            
            flash(f'چک الکترونیک به مبلغ {net_amount:,.0f} تومان صادر شد. کمیسیون سیستم {system_commission:,.0f} تومان کسر گردید.', 'success')
            return redirect(url_for('admin.payment_releases'))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error processing payment release: {str(e)}")
            flash(f'خطا در پردازش: {str(e)}', 'danger')
    
    return render_template('admin/process_payment_release.html', 
                         release=release, 
                         form=form, 
                         system_commission=system_commission, 
                         net_amount=net_amount)


@admin_bp.route('/payment-release/<int:release_id>/smart-verify', methods=['POST'])
@login_required
def verify_payment_release_smart(release_id):
    """بررسی هوشمند و تایید درخواست آزادسازی بر اساس حضور غیاب"""
    if current_user.role != 'admin':
        return jsonify({'error': 'دسترسی غیرمجاز'}), 403
    
    release = PaymentRelease.query.get_or_404(release_id)
    
    try:
        # بررسی گزارش‌های هوشمند برای این قرارداد
        smart_reports = SmartReport.query.filter_by(
            contract_id=release.contract_id
        ).order_by(SmartReport.report_date.desc()).limit(3).all()
        
        if not smart_reports:
            return jsonify({
                'status': 'error',
                'message': 'هیچ گزارش هوشمندی برای این قرارداد وجود ندارد'
            }), 400
        
        # بررسی تاییدات مدیر و کارفرما
        manager_approved = all(r.manager_approved for r in smart_reports)
        employer_approved = all(r.employer_approved for r in smart_reports)
        
        if manager_approved and employer_approved:
            # بررسی درصد حضور
            avg_attendance = sum(r.attendance_percentage for r in smart_reports) / len(smart_reports)
            
            if avg_attendance >= 80:  # بیش از 80% حضور
                release.admin_approved = True
                release.admin_approved_at = datetime.utcnow()
                release.status = 'approved'
                release.smart_verified = True
                release.attendance_percentage = avg_attendance
                
                db.session.commit()
                
                return jsonify({
                    'status': 'success',
                    'message': f'درخواست آزادسازی تایید شد. درصد حضور: {avg_attendance:.1f}%',
                    'attendance_percentage': avg_attendance
                })
            else:
                return jsonify({
                    'status': 'warning',
                    'message': f'درصد حضور {avg_attendance:.1f}% است که کمتر از حد مجاز (80%) می‌باشد',
                    'attendance_percentage': avg_attendance
                })
        else:
            return jsonify({
                'status': 'warning',
                'message': 'تاییدات مدیر و کارفرما کامل نیست'
            })
            
    except Exception as e:
        db.session.rollback()
        logger.error(f"Error in smart verification: {str(e)}")
        return jsonify({'error': str(e)}), 500

# ==================== 7. مدیریت گزارش‌های هوشمند ====================

@admin_bp.route('/smart-reports')
@login_required
def smart_reports():
    """گزارش‌های هوشمند حضور"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    try:
        # به‌روزرسانی خودکار گزارش‌ها
        contracts = Contract.query.filter_by(is_active=True).all()
        current_month = datetime.now().replace(day=1)
        
        for contract in contracts:
            if contract.employee_id:
                # محاسبه تعداد حضور در ماه جاری
                attendances = Attendance.query.filter(
                    Attendance.employee_id == contract.employee_id,
                    Attendance.project_id == contract.project_id,
                    func.date(Attendance.check_in_time) >= current_month.date(),
                    Attendance.status == 'present'
                ).count()
                
                required_days = 22
                
                smart_report = SmartReport.query.filter_by(
                    contract_id=contract.id,
                    report_date=current_month.date()
                ).first()
                
                if not smart_report:
                    smart_report = SmartReport(
                        project_id=contract.project_id,
                        employee_id=contract.employee_id,
                        contract_id=contract.id,
                        report_date=current_month.date(),
                        required_attendance=required_days,
                        attendance_count=attendances
                    )
                    db.session.add(smart_report)
                else:
                    smart_report.attendance_count = attendances
                
                smart_report.attendance_percentage = (attendances / required_days) * 100
                
                if attendances >= required_days * 0.8:
                    smart_report.smart_status = 'positive'
                else:
                    smart_report.smart_status = 'negative'
        
        db.session.commit()
        
    except Exception as e:
        logger.error(f"Error updating smart reports: {str(e)}")
        flash(f'خطا در به‌روزرسانی گزارش‌های هوشمند: {str(e)}', 'warning')
    
    pending_reports = SmartReport.query.filter_by(
        admin_verified=False
    ).order_by(SmartReport.report_date.desc()).all()
    
    verified_reports = SmartReport.query.filter_by(
        admin_verified=True
    ).order_by(SmartReport.report_date.desc()).limit(50).all()
    
    return render_template('admin/smart_reports.html', 
                         pending_reports=pending_reports,
                         verified_reports=verified_reports)


@admin_bp.route('/smart-report/<int:report_id>/verify', methods=['POST'])
@login_required
def verify_smart_report(report_id):
    """تایید گزارش هوشمند و فعالسازی چک"""
    if current_user.role != 'admin':
        return jsonify({'error': 'دسترسی غیرمجاز'}), 403
    
    report = SmartReport.query.get_or_404(report_id)
    data = request.get_json()
    
    try:
        # بررسی تاییدات مدیر و کارفرما
        manager_approved = report.manager_approved
        employer_approved = report.employer_approved
        
        if report.smart_status == 'positive' and manager_approved and employer_approved:
            report.admin_verified = True
            report.final_status = 'approved'
            report.verified_by = current_user.id
            report.verified_at = datetime.utcnow()
            
            # فعالسازی چک‌های مرتبط
            payment_releases = PaymentRelease.query.filter_by(
                contract_id=report.contract_id,
                status='pending'
            ).all()
            
            activated_count = 0
            for release in payment_releases:
                if release.electronic_check_id:
                    check = ElectronicCheck.query.get(release.electronic_check_id)
                    if check and check.status == 'issued':
                        check.status = 'active'
                        
                        transaction = CheckTransaction(
                            check_id=check.id,
                            transaction_type='activate',
                            before_status='issued',
                            after_status='active',
                            reason='تایید گزارش هوشمند حضور',
                            performed_by=current_user.id
                        )
                        db.session.add(transaction)
                        activated_count += 1
            
            db.session.commit()
            
            # ارسال نوتیفیکیشن
            if report.employee_id:
                send_notification(
                    report.employee_id,
                    'تایید گزارش هوشمند',
                    f'گزارش حضور شما برای ماه {report.report_date.strftime("%B %Y")} تایید شد.',
                    'success'
                )
            
            return jsonify({
                'status': 'success', 
                'message': f'گزارش تایید و {activated_count} چک فعال شدند'
            })
            
        elif report.smart_status == 'negative' or not (manager_approved and employer_approved):
            report.admin_verified = True
            report.final_status = 'rejected'
            report.verified_by = current_user.id
            report.verified_at = datetime.utcnow()
            report.rejection_reason = data.get('reason', 'عدم احراز شرایط حضور')
            
            db.session.commit()
            
            return jsonify({
                'status': 'warning', 
                'message': 'گزارش رد شد - عدم احراز شرایط'
            })
        
        return jsonify({'status': 'error', 'message': 'شرایط تایید فراهم نیست'})
        
    except Exception as e:
        db.session.rollback()
        logger.error(f"Error verifying smart report: {str(e)}")
        return jsonify({'error': str(e)}), 500

# ==================== 8. مدیریت دفترچه چک بانکی ====================

@admin_bp.route('/bank-check-books')
@login_required
def bank_check_books_list():
    """لیست دفترچه چک‌های بانکی"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    check_books = BankCheckBook.query.order_by(
        BankCheckBook.created_at.desc()
    ).all()
    
    projects = Project.query.filter_by(status='active').all()
    
    return render_template('admin/bank_check_books.html', 
                         check_books=check_books, 
                         projects=projects)


@admin_bp.route('/bank-check-book/create', methods=['POST'])
@login_required
def create_bank_check_book():
    """ایجاد دفترچه چک جدید (دریافت از بانک)"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    try:
        bank_name = request.form.get('bank_name')
        account_number = request.form.get('account_number')
        account_owner = request.form.get('account_owner')
        project_id = request.form.get('project_id')
        start_number = request.form.get('start_number')
        end_number = request.form.get('end_number')
        received_date = datetime.strptime(request.form.get('received_date'), '%Y-%m-%d').date()
        
        escrow = EscrowAccount.query.filter_by(project_id=project_id).first()
        if not escrow:
            flash('ابتدا باید صندوق امانی برای این پروژه ایجاد شود', 'danger')
            return redirect(url_for('admin.bank_check_books_list'))
        
        check_book = BankCheckBook(
            bank_name=bank_name,
            account_number=account_number,
            account_owner=account_owner,
            project_id=project_id,
            start_number=start_number,
            end_number=end_number,
            current_number=start_number,
            received_date=received_date,
            created_by=current_user.id
        )
        check_book.calculate_counts()
        
        # ایجاد رکوردهای جداگانه برای هر چک
        for i in range(int(start_number), int(end_number) + 1):
            bank_check = BankCheck(
                check_book_id=check_book.id,
                check_number=str(i),
                serial_number=f"{bank_name}_{account_number}_{i}",
                status='available'
            )
            db.session.add(bank_check)
        
        db.session.add(check_book)
        db.session.commit()
        
        flash(f'دفترچه چک با محدوده {start_number} تا {end_number} با موفقیت ثبت شد', 'success')
        
    except Exception as e:
        db.session.rollback()
        logger.error(f"Error creating check book: {str(e)}")
        flash(f'خطا در ثبت دفترچه چک: {str(e)}', 'danger')
    
    return redirect(url_for('admin.bank_check_books_list'))


@admin_bp.route('/bank-checks')
@login_required
def bank_checks_list():
    """لیست تمام چک‌های بانکی"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    status_filter = request.args.get('status', '')
    project_id = request.args.get('project_id', '')
    
    query = BankCheck.query.join(BankCheckBook)
    
    if status_filter:
        query = query.filter(BankCheck.status == status_filter)
    if project_id:
        query = query.filter(BankCheckBook.project_id == project_id)
    
    checks = query.order_by(BankCheck.created_at.desc()).all()
    projects = Project.query.filter_by(status='active').all()
    
    return render_template('admin/bank_checks.html', 
                         checks=checks, 
                         projects=projects,
                         status_filter=status_filter,
                         project_id=project_id)


@admin_bp.route('/bank-check/<int:check_id>/return', methods=['POST'])
@login_required
def return_bank_check(check_id):
    """بازگرداندن چک به بانک (در صورت عدم استفاده)"""
    if current_user.role != 'admin':
        return jsonify({'error': 'دسترسی غیرمجاز'}), 403
    
    check = BankCheck.query.get_or_404(check_id)
    reason = request.json.get('reason', '')
    
    if check.status not in ['available', 'allocated']:
        return jsonify({'error': 'این چک قابل بازگشت نیست'}), 400
    
    try:
        check.status = 'returned'
        
        transaction = CheckTransaction(
            electronic_check_id=None,
            bank_check_id=check.id,
            bank_check_number=check.check_number,
            transaction_type='return',
            amount=0,
            reason=reason,
            performed_by=current_user.id
        )
        db.session.add(transaction)
        db.session.commit()
        
        return jsonify({'success': True, 'message': 'چک با موفقیت به بانک بازگردانده شد'})
    except Exception as e:
        db.session.rollback()
        logger.error(f"Error returning bank check: {str(e)}")
        return jsonify({'error': str(e)}), 500

# ==================== 9. مدیریت کمیسیون مدیران ====================

@admin_bp.route('/manager-commissions')
@login_required
def manager_commissions():
    """مدیریت کمیسیون مدیران"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    try:
        # محاسبه کمیسیون‌های پرداخت نشده
        pending_commissions = SystemCommission.query.filter_by(
            status='pending'
        ).all()
        
        # جمع کل کمیسیون هر مدیر
        manager_totals = db.session.query(
            SystemCommission.manager_id,
            User.fullname,
            func.sum(SystemCommission.manager_commission_amount).label('total')
        ).join(User, User.id == SystemCommission.manager_id).filter(
            SystemCommission.status == 'pending'
        ).group_by(SystemCommission.manager_id).all()
        
        return render_template('admin/manager_commissions.html',
                             pending_commissions=pending_commissions,
                             manager_totals=manager_totals)
                             
    except Exception as e:
        logger.error(f"Error in manager commissions: {str(e)}")
        flash(f'خطا در بارگذاری کمیسیون‌ها: {str(e)}', 'danger')
        return render_template('admin/manager_commissions.html', 
                             pending_commissions=[], 
                             manager_totals=[])


@admin_bp.route('/issue-manager-check/<int:commission_id>', methods=['POST'])
@login_required
def issue_manager_check(commission_id):
    """صدور چک الکترونیک برای کمیسیون مدیر"""
    if current_user.role != 'admin':
        return jsonify({'error': 'دسترسی غیرمجاز'}), 403
    
    commission = SystemCommission.query.get_or_404(commission_id)
    
    if commission.status != 'pending':
        return jsonify({'status': 'error', 'message': 'کمیسیون قبلاً پرداخت شده است'})
    
    try:
        # ایجاد چک الکترونیک برای مدیر
        check = ElectronicCheck(
            amount=commission.manager_commission_amount,
            recipient_name=commission.manager.fullname,
            recipient_phone=commission.manager.phone,
            due_date=datetime.utcnow() + timedelta(days=7),
            bank_name='کمیسیون سامانه',
            description=f'کمیسیون مدیر پروژه بابت قرارداد {commission.contract_id} - واریزی {commission.total_amount:,.0f} تومان',
            status='issued'
        )
        check.generate_check_number()
        db.session.add(check)
        
        commission.manager_check_id = check.id
        commission.status = 'paid'
        commission.paid_at = datetime.utcnow()
        
        # ثبت تراکنش
        transaction = CheckTransaction(
            check_id=check.id,
            transaction_type='issue',
            amount=commission.manager_commission_amount,
            before_status='pending',
            after_status='issued',
            reason=f'صدور چک کمیسیون مدیر - قرارداد {commission.contract_id}',
            performed_by=current_user.id
        )
        db.session.add(transaction)
        
        db.session.commit()
        
        # ارسال نوتیفیکیشن به مدیر
        send_notification(
            commission.manager_id,
            'صدور چک کمیسیون',
            f'چک کمیسیون به شماره {check.check_number} به مبلغ {commission.manager_commission_amount:,.0f} تومان صادر شد.',
            'success'
        )
        
        return jsonify({
            'status': 'success',
            'message': f'چک کمیسیون به مبلغ {commission.manager_commission_amount:,.0f} تومان صادر شد',
            'check_number': check.check_number
        })
        
    except Exception as e:
        db.session.rollback()
        logger.error(f"Error issuing manager check: {str(e)}")
        return jsonify({'status': 'error', 'message': str(e)}), 500

# ==================== 10. مدیریت پروژه ====================

@admin_bp.route('/project/<int:project_id>')
@login_required
def project_detail(project_id):
    """جزئیات پروژه برای ادمین"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('admin.dashboard'))
    
    project = Project.query.get_or_404(project_id)
    
    escrow_account = EscrowAccount.query.filter_by(project_id=project.id).first()
    
    project_employees = ProjectEmployee.query.filter_by(
        project_id=project.id,
        is_active=True
    ).all()
    
    contracts = Contract.query.filter_by(
        project_id=project.id
    ).all()
    
    return render_template(
        'admin/project_detail.html',
        project=project,
        escrow_account=escrow_account,
        project_employees=project_employees,
        contracts=contracts
    )

# ==================== 11. پروفایل ادمین ====================

@admin_bp.route('/profile')
@login_required
def profile():
    """پروفایل ادمین"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('admin.index'))
    return render_template('admin/profile.html', user=current_user)

# ==================== 12. مدیریت صندوق امانی - جزئیات ====================

@admin_bp.route('/escrow/<int:escrow_id>/details')
@login_required
def escrow_details(escrow_id):
    """جزئیات صندوق امانی"""
    if current_user.role != 'admin':
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    escrow = EscrowAccount.query.get_or_404(escrow_id)
    deposits = Deposit.query.filter_by(escrow_id=escrow_id).all()
    releases = PaymentRelease.query.filter_by(escrow_id=escrow_id, admin_approved=True).all()
    
    return render_template('admin/escrow_details.html', 
                         escrow=escrow, 
                         deposits=deposits, 
                         releases=releases)

# ==================== 13. صدور چک از صندوق امانی ====================

@admin_bp.route('/project/<int:project_id>/electronic-check', methods=['GET', 'POST'])
@login_required
def issue_electronic_check(project_id):
    """صدور چک الکترونیک از صندوق امانی (فقط ادمین)"""
    if current_user.role not in ['admin']:
        flash('دسترسی غیرمجاز', 'danger')
        return redirect(url_for('auth.dashboard'))
    
    project = Project.query.get_or_404(project_id)
    form = ElectronicCheckForm()
    form.project_id.choices = [(project.id, project.name)]
    
    form.employee_id.choices = [(0, '--- انتخاب گیرنده ---')] + [
        (pe.employee_id, pe.employee.fullname) for pe in project.employees if pe.is_active
    ] + [(project.employer_id, 'کارفرما')] if project.employer_id else []
    
    if form.validate_on_submit():
        # بررسی موجودی صندوق امانی
        escrow = EscrowAccount.query.filter_by(project_id=project.id).first()
        if escrow and escrow.balance < form.amount.data:
            flash('❌ موجودی صندوق امانی کافی نیست', 'danger')
            return render_template('admin/electronic_check_form.html', form=form, project=project)
        
        try:
            check = ElectronicCheck(
                project_id=project.id,
                employee_id=form.employee_id.data if form.employee_id.data != 0 else None,
                employer_id=project.employer_id if form.employee_id.data == 0 else None,
                amount=form.amount.data,
                check_number=form.check_number.data,
                issue_date=form.issue_date.data,
                due_date=form.due_date.data,
                bank_name=form.bank_name.data,
                account_number=form.account_number.data,
                description=form.description.data,
                status='issued',
                issued_by=current_user.id
            )
            check.generate_check_number()
            db.session.add(check)
            
            if escrow:
                escrow.balance -= form.amount.data
                
                # ثبت تراکنش
                transaction = EscrowTransaction(
                    escrow_id=escrow.id,
                    project_id=project.id,
                    transaction_type='withdrawal',
                    amount=form.amount.data,
                    description=f'صدور چک به شماره {check.check_number} - {form.description.data}',
                    performed_by=current_user.id
                )
                db.session.add(transaction)
            
            db.session.commit()
            
            # ارسال نوتیفیکیشن
            recipient_id = form.employee_id.data if form.employee_id.data != 0 else project.employer_id
            if recipient_id:
                send_notification(
                    recipient_id,
                    'صدور چک الکترونیک',
                    f'چک به شماره {check.check_number} به مبلغ {form.amount.data:,.0f} تومان صادر شد.',
                    'success'
                )
            
            flash(f'✅ چک الکترونیک به شماره {check.check_number} با موفقیت صادر شد', 'success')
            return redirect(url_for('admin.project_detail', project_id=project.id))
            
        except Exception as e:
            db.session.rollback()
            logger.error(f"Error issuing check: {str(e)}")
            flash(f'❌ خطا در صدور چک: {str(e)}', 'danger')
    
    return render_template('admin/electronic_check_form.html', form=form, project=project)