"""
Admin panel routes for ScholarPress.
"""

from flask import Blueprint, render_template, request, redirect, url_for, flash, current_app, send_from_directory
from flask_login import login_required, current_user
from functools import wraps
from datetime import datetime
import os

from app import db
from app.models import (
    User, Journal, Article, Tag, Submission, SubmissionStatusUpdate,
    ContactThread, ContactMessage, SiteSettings, ContentBlock, PageImage
)
from app.utils import (
    save_file, save_image, delete_file, generate_unique_slug, allowed_file, allowed_image
)
from app.utils.email import send_submission_status_update, send_contact_reply_notification

admin_bp = Blueprint('admin', __name__)


def admin_required(f):
    """Decorator to require admin role."""
    @wraps(f)
    def decorated_function(*args, **kwargs):
        if not current_user.is_authenticated or not current_user.is_admin():
            flash('You do not have permission to access this page.', 'danger')
            return redirect(url_for('auth.login'))
        return f(*args, **kwargs)
    return decorated_function


@admin_bp.before_request
@login_required
@admin_required
def before_request():
    """Ensure all admin routes require authentication and admin role."""
    pass


# ==================== Dashboard ====================

@admin_bp.route('/')
def dashboard():
    """Admin dashboard."""
    stats = {
        'total_articles': Article.query.count(),
        'published_articles': Article.query.filter_by(is_published=True).count(),
        'total_journals': Journal.query.count(),
        'pending_submissions': Submission.query.filter_by(status='pending').count(),
        'in_review_submissions': Submission.query.filter_by(status='under_review').count(),
        'total_users': User.query.count(),
        'unread_messages': ContactThread.query.filter_by(is_closed=False).count()
    }
    
    recent_submissions = Submission.query.order_by(Submission.created_at.desc()).limit(5).all()
    recent_messages = ContactThread.query.order_by(ContactThread.updated_at.desc()).limit(5).all()
    
    return render_template('admin/dashboard.html',
                         stats=stats,
                         recent_submissions=recent_submissions,
                         recent_messages=recent_messages)


# ==================== User Management ====================

@admin_bp.route('/users')
def users():
    """List all users."""
    page = request.args.get('page', 1, type=int)
    users = User.query.order_by(User.created_at.desc()).paginate(page=page, per_page=20, error_out=False)
    return render_template('admin/users/list.html', users=users)


@admin_bp.route('/users/add', methods=['GET', 'POST'])
def add_user():
    """Add a new user."""
    if request.method == 'POST':
        email = request.form.get('email', '').strip()
        username = request.form.get('username', '').strip()
        name = request.form.get('name', '').strip()
        password = request.form.get('password', '')
        role = request.form.get('role', 'editor')
        
        # Validate
        errors = []
        if not email:
            errors.append('Email is required.')
        elif User.query.filter_by(email=email).first():
            errors.append('Email already exists.')
        
        if not username:
            errors.append('Username is required.')
        elif User.query.filter_by(username=username).first():
            errors.append('Username already exists.')
        
        if not password or len(password) < 6:
            errors.append('Password must be at least 6 characters.')
        
        if role not in ['admin', 'editor']:
            errors.append('Invalid role.')
        
        if errors:
            for error in errors:
                flash(error, 'danger')
            return render_template('admin/users/form.html', user=None)
        
        user = User(email=email, username=username, name=name or None, role=role, is_active=True)
        user.set_password(password)
        db.session.add(user)
        db.session.commit()
        
        flash(f'User {username} created successfully.', 'success')
        return redirect(url_for('admin.users'))
    
    return render_template('admin/users/form.html', user=None)


@admin_bp.route('/users/<int:id>/edit', methods=['GET', 'POST'])
def edit_user(id):
    """Edit a user."""
    user = User.query.get_or_404(id)
    
    if request.method == 'POST':
        email = request.form.get('email', '').strip()
        username = request.form.get('username', '').strip()
        name = request.form.get('name', '').strip()
        password = request.form.get('password', '')
        role = request.form.get('role', 'editor')
        is_active = request.form.get('is_active') == 'on'
        
        # Validate
        errors = []
        if not email:
            errors.append('Email is required.')
        elif User.query.filter(User.email == email, User.id != id).first():
            errors.append('Email already exists.')
        
        if not username:
            errors.append('Username is required.')
        elif User.query.filter(User.username == username, User.id != id).first():
            errors.append('Username already exists.')
        
        if role not in ['admin', 'editor']:
            errors.append('Invalid role.')
        
        if errors:
            for error in errors:
                flash(error, 'danger')
            return render_template('admin/users/form.html', user=user)
        
        user.email = email
        user.username = username
        user.name = name or None
        user.role = role
        user.is_active = is_active
        
        if password:
            if len(password) < 6:
                flash('Password must be at least 6 characters.', 'danger')
                return render_template('admin/users/form.html', user=user)
            user.set_password(password)
        
        db.session.commit()
        flash(f'User {username} updated successfully.', 'success')
        return redirect(url_for('admin.users'))
    
    return render_template('admin/users/form.html', user=user)


@admin_bp.route('/users/<int:id>/delete', methods=['POST'])
def delete_user(id):
    """Delete a user."""
    user = User.query.get_or_404(id)
    
    if user.id == current_user.id:
        flash('You cannot delete your own account.', 'danger')
        return redirect(url_for('admin.users'))
    
    db.session.delete(user)
    db.session.commit()
    flash(f'User {user.username} deleted successfully.', 'success')
    return redirect(url_for('admin.users'))


# ==================== Journal Management ====================

@admin_bp.route('/journals')
def journals():
    """List all journals."""
    journals = Journal.query.order_by(Journal.name).all()
    return render_template('admin/journals/list.html', journals=journals)


@admin_bp.route('/journals/add', methods=['GET', 'POST'])
def add_journal():
    """Add a new journal."""
    if request.method == 'POST':
        name = request.form.get('name', '').strip()
        custom_slug = request.form.get('slug', '').strip()
        description = request.form.get('description', '').strip()
        issn = request.form.get('issn', '').strip()
        founded_year = request.form.get('founded_year', type=int)
        impact_factor = request.form.get('impact_factor', '').strip()
        frequency = request.form.get('frequency', '').strip()
        editor = request.form.get('editor', '').strip()
        is_open_access = request.form.get('is_open_access') == 'on'
        is_active = request.form.get('is_active') == 'on'
        
        if not name:
            flash('Journal name is required.', 'danger')
            return render_template('admin/journals/form.html', journal=None)
        
        slug = custom_slug if custom_slug else generate_unique_slug(name, Journal)
        
        journal = Journal(
            name=name,
            slug=slug,
            description=description,
            issn=issn,
            founded_year=founded_year,
            impact_factor=impact_factor,
            frequency=frequency,
            editor=editor,
            is_open_access=is_open_access,
            is_active=is_active
        )
        
        # Handle cover image upload
        cover_image = request.files.get('cover_image')
        if cover_image and cover_image.filename:
            if allowed_image(cover_image.filename):
                journal.cover_image = save_image(cover_image, 'journals')
            else:
                flash('Invalid image format.', 'warning')
        
        db.session.add(journal)
        db.session.commit()
        
        flash(f'Journal "{name}" created successfully.', 'success')
        return redirect(url_for('admin.journals'))
    
    return render_template('admin/journals/form.html', journal=None)


@admin_bp.route('/journals/<int:id>/edit', methods=['GET', 'POST'])
def edit_journal(id):
    """Edit a journal."""
    journal = Journal.query.get_or_404(id)
    
    if request.method == 'POST':
        name = request.form.get('name', '').strip()
        custom_slug = request.form.get('slug', '').strip()
        description = request.form.get('description', '').strip()
        issn = request.form.get('issn', '').strip()
        founded_year = request.form.get('founded_year', type=int)
        impact_factor = request.form.get('impact_factor', '').strip()
        frequency = request.form.get('frequency', '').strip()
        editor = request.form.get('editor', '').strip()
        is_open_access = request.form.get('is_open_access') == 'on'
        is_active = request.form.get('is_active') == 'on'
        
        if not name:
            flash('Journal name is required.', 'danger')
            return render_template('admin/journals/form.html', journal=journal)
        
        journal.name = name
        journal.slug = custom_slug if custom_slug else generate_unique_slug(name, Journal, journal.id)
        journal.description = description
        journal.issn = issn
        journal.founded_year = founded_year
        journal.impact_factor = impact_factor
        journal.frequency = frequency
        journal.editor = editor
        journal.is_open_access = is_open_access
        journal.is_active = is_active
        
        # Handle cover image upload
        cover_image = request.files.get('cover_image')
        if cover_image and cover_image.filename:
            if allowed_image(cover_image.filename):
                # Delete old image
                if journal.cover_image:
                    delete_file(journal.cover_image)
                journal.cover_image = save_image(cover_image, 'journals')
            else:
                flash('Invalid image format.', 'warning')
        
        db.session.commit()
        flash(f'Journal "{name}" updated successfully.', 'success')
        return redirect(url_for('admin.journals'))
    
    return render_template('admin/journals/form.html', journal=journal)


@admin_bp.route('/journals/<int:id>/delete', methods=['POST'])
def delete_journal(id):
    """Delete a journal."""
    journal = Journal.query.get_or_404(id)
    
    if journal.articles.count() > 0:
        flash('Cannot delete journal with existing articles. Please remove articles first.', 'danger')
        return redirect(url_for('admin.journals'))
    
    if journal.cover_image:
        delete_file(journal.cover_image)
    
    db.session.delete(journal)
    db.session.commit()
    flash(f'Journal "{journal.name}" deleted successfully.', 'success')
    return redirect(url_for('admin.journals'))


# ==================== Article Management ====================

@admin_bp.route('/articles')
def articles():
    """List all articles."""
    page = request.args.get('page', 1, type=int)
    status = request.args.get('status', '')
    journal_id = request.args.get('journal', type=int)
    
    query = Article.query
    
    if status == 'published':
        query = query.filter_by(is_published=True)
    elif status == 'draft':
        query = query.filter_by(is_published=False)
    
    if journal_id:
        query = query.filter_by(journal_id=journal_id)
    
    articles = query.order_by(Article.created_at.desc()).paginate(page=page, per_page=20, error_out=False)
    journals = Journal.query.order_by(Journal.name).all()
    
    return render_template('admin/articles/list.html', articles=articles, journals=journals)


@admin_bp.route('/articles/add', methods=['GET', 'POST'])
def add_article():
    """Add a new article."""
    journals = Journal.query.filter_by(is_active=True).order_by(Journal.name).all()
    all_tags = Tag.query.order_by(Tag.name).all()
    
    if request.method == 'POST':
        title = request.form.get('title', '').strip()
        abstract = request.form.get('abstract', '').strip()
        content = request.form.get('content', '').strip()
        authors = request.form.get('authors', '').strip()
        journal_id = request.form.get('journal_id', type=int)
        tag_ids = request.form.getlist('tags', type=int)
        is_published = request.form.get('is_published') == 'on'
        is_open_access = request.form.get('is_open_access') == 'on'
        keywords = request.form.get('keywords', '').strip()
        volume = request.form.get('volume', '').strip()
        issue = request.form.get('issue', '').strip()
        pages = request.form.get('pages', '').strip()
        doi = request.form.get('doi', '').strip()
        meta_title = request.form.get('meta_title', '').strip()
        meta_description = request.form.get('meta_description', '').strip()
        meta_keywords = request.form.get('meta_keywords', '').strip()
        
        errors = []
        if not title:
            errors.append('Title is required.')
        if not journal_id:
            errors.append('Journal is required.')
        
        if errors:
            for error in errors:
                flash(error, 'danger')
            return render_template('admin/articles/form.html', article=None, journals=journals, all_tags=all_tags)
        
        custom_slug = request.form.get('slug', '').strip()
        article = Article(
            title=title,
            slug=custom_slug if custom_slug else generate_unique_slug(title, Article),
            abstract=abstract,
            content=content,
            authors=authors,
            keywords=keywords,
            volume=volume,
            issue=issue,
            pages=pages,
            journal_id=journal_id,
            author_id=current_user.id,
            is_published=is_published,
            is_open_access=is_open_access,
            meta_title=meta_title or title[:200],
            meta_description=meta_description or abstract[:500] if abstract else '',
            meta_keywords=meta_keywords
        )
        
        if is_published:
            published_date_str = request.form.get('published_date', '').strip()
            if published_date_str:
                try:
                    article.published_date = datetime.strptime(published_date_str, '%Y-%m-%d')
                except ValueError:
                    article.published_date = datetime.utcnow()
            else:
                article.published_date = datetime.utcnow()
        
        # Add tags
        if tag_ids:
            tags = Tag.query.filter(Tag.id.in_(tag_ids)).all()
            article.tags = tags
        
        # Handle PDF upload
        pdf_file = request.files.get('pdf_file')
        if pdf_file and pdf_file.filename:
            if allowed_file(pdf_file.filename):
                article.pdf_file = save_file(pdf_file, 'articles')
            else:
                flash('Invalid file format. Only PDF, DOCX, DOC, TXT allowed.', 'warning')
        
        db.session.add(article)
        db.session.flush()  # Get the article ID before generating DOI
        
        if doi:
            article.doi = doi
        elif is_published:
            article.doi = article.generate_doi()
        
        db.session.commit()
        
        flash(f'Article "{title}" created successfully.', 'success')
        return redirect(url_for('admin.articles'))
    
    return render_template('admin/articles/form.html', article=None, journals=journals, all_tags=all_tags)


@admin_bp.route('/articles/<int:id>/edit', methods=['GET', 'POST'])
def edit_article(id):
    """Edit an article."""
    article = Article.query.get_or_404(id)
    journals = Journal.query.filter_by(is_active=True).order_by(Journal.name).all()
    all_tags = Tag.query.order_by(Tag.name).all()
    
    if request.method == 'POST':
        title = request.form.get('title', '').strip()
        abstract = request.form.get('abstract', '').strip()
        content = request.form.get('content', '').strip()
        authors = request.form.get('authors', '').strip()
        journal_id = request.form.get('journal_id', type=int)
        tag_ids = request.form.getlist('tags', type=int)
        is_published = request.form.get('is_published') == 'on'
        is_open_access = request.form.get('is_open_access') == 'on'
        keywords = request.form.get('keywords', '').strip()
        volume = request.form.get('volume', '').strip()
        issue = request.form.get('issue', '').strip()
        pages = request.form.get('pages', '').strip()
        doi = request.form.get('doi', '').strip()
        meta_title = request.form.get('meta_title', '').strip()
        meta_description = request.form.get('meta_description', '').strip()
        meta_keywords = request.form.get('meta_keywords', '').strip()
        
        if not title:
            flash('Title is required.', 'danger')
            return render_template('admin/articles/form.html', article=article, journals=journals, all_tags=all_tags)
        
        was_published = article.is_published
        
        custom_slug = request.form.get('slug', '').strip()
        article.title = title
        article.slug = custom_slug if custom_slug else generate_unique_slug(title, Article, article.id)
        article.abstract = abstract
        article.content = content
        article.authors = authors
        article.keywords = keywords
        article.volume = volume
        article.issue = issue
        article.pages = pages
        article.journal_id = journal_id
        article.is_published = is_published
        article.is_open_access = is_open_access
        article.meta_title = meta_title or title[:200]
        article.meta_description = meta_description or abstract[:500] if abstract else ''
        article.meta_keywords = meta_keywords
        
        # Set published date
        published_date_str = request.form.get('published_date', '').strip()
        if published_date_str:
            try:
                article.published_date = datetime.strptime(published_date_str, '%Y-%m-%d')
            except ValueError:
                pass
        elif is_published and not article.published_date:
            article.published_date = datetime.utcnow()
        
        # Update DOI
        if doi:
            article.doi = doi
        elif is_published and not article.doi:
            article.doi = article.generate_doi()
        
        # Update tags
        tags = Tag.query.filter(Tag.id.in_(tag_ids)).all() if tag_ids else []
        article.tags = tags
        
        # Handle PDF upload
        pdf_file = request.files.get('pdf_file')
        if pdf_file and pdf_file.filename:
            if allowed_file(pdf_file.filename):
                if article.pdf_file:
                    delete_file(article.pdf_file)
                article.pdf_file = save_file(pdf_file, 'articles')
            else:
                flash('Invalid file format. Only PDF, DOCX, DOC, TXT allowed.', 'warning')
        
        db.session.commit()
        flash(f'Article "{title}" updated successfully.', 'success')
        return redirect(url_for('admin.articles'))
    
    return render_template('admin/articles/form.html', article=article, journals=journals, all_tags=all_tags)


@admin_bp.route('/articles/<int:id>/delete', methods=['POST'])
def delete_article(id):
    """Delete an article."""
    article = Article.query.get_or_404(id)
    
    if article.pdf_file:
        delete_file(article.pdf_file)
    
    db.session.delete(article)
    db.session.commit()
    flash(f'Article deleted successfully.', 'success')
    return redirect(url_for('admin.articles'))


# ==================== Tag Management ====================

@admin_bp.route('/tags')
def tags():
    """List all tags."""
    tags = Tag.query.order_by(Tag.name).all()
    return render_template('admin/tags/list.html', tags=tags)


@admin_bp.route('/tags/add', methods=['GET', 'POST'])
def add_tag():
    """Add a new tag."""
    if request.method == 'POST':
        name = request.form.get('name', '').strip()
        
        if not name:
            flash('Tag name is required.', 'danger')
            return render_template('admin/tags/form.html', tag=None)
        
        if Tag.query.filter_by(name=name).first():
            flash('Tag already exists.', 'danger')
            return render_template('admin/tags/form.html', tag=None)
        
        tag = Tag(name=name, slug=generate_unique_slug(name, Tag))
        db.session.add(tag)
        db.session.commit()
        
        flash(f'Tag "{name}" created successfully.', 'success')
        return redirect(url_for('admin.tags'))
    
    return render_template('admin/tags/form.html', tag=None)


@admin_bp.route('/tags/<int:id>/edit', methods=['GET', 'POST'])
def edit_tag(id):
    """Edit a tag."""
    tag = Tag.query.get_or_404(id)
    
    if request.method == 'POST':
        name = request.form.get('name', '').strip()
        
        if not name:
            flash('Tag name is required.', 'danger')
            return render_template('admin/tags/form.html', tag=tag)
        
        if Tag.query.filter(Tag.name == name, Tag.id != id).first():
            flash('Tag already exists.', 'danger')
            return render_template('admin/tags/form.html', tag=tag)
        
        tag.name = name
        tag.slug = generate_unique_slug(name, Tag, tag.id)
        db.session.commit()
        
        flash(f'Tag "{name}" updated successfully.', 'success')
        return redirect(url_for('admin.tags'))
    
    return render_template('admin/tags/form.html', tag=tag)


@admin_bp.route('/tags/<int:id>/delete', methods=['POST'])
def delete_tag(id):
    """Delete a tag."""
    tag = Tag.query.get_or_404(id)
    db.session.delete(tag)
    db.session.commit()
    flash(f'Tag deleted successfully.', 'success')
    return redirect(url_for('admin.tags'))


# ==================== Submission Management ====================

@admin_bp.route('/submissions')
def submissions():
    """List all submissions."""
    page = request.args.get('page', 1, type=int)
    status = request.args.get('status', '')
    
    query = Submission.query
    
    if status:
        query = query.filter_by(status=status)
    
    submissions = query.order_by(Submission.created_at.desc()).paginate(page=page, per_page=15, error_out=False)
    
    stats = {
        'pending': Submission.query.filter_by(status='pending').count(),
        'under_review': Submission.query.filter_by(status='under_review').count(),
        'revision': Submission.query.filter_by(status='revision_requested').count(),
        'accepted': Submission.query.filter_by(status='accepted').count(),
        'published': Submission.query.filter_by(status='published').count(),
        'rejected': Submission.query.filter_by(status='rejected').count(),
    }
    
    return render_template('admin/submissions/list.html', submissions=submissions, current_status=status, stats=stats)


@admin_bp.route('/submissions/<int:id>')
def view_submission(id):
    """View submission details."""
    submission = Submission.query.get_or_404(id)
    return render_template('admin/submissions/view.html', submission=submission)


@admin_bp.route('/submissions/<int:id>/update-status', methods=['POST'])
def update_submission_status(id):
    """Update submission status."""
    submission = Submission.query.get_or_404(id)
    
    new_status = request.form.get('status', '').strip()
    notes = request.form.get('notes', '').strip()
    
    valid_statuses = ['pending', 'under_review', 'revision_requested', 'accepted', 'rejected', 'published']
    if new_status not in valid_statuses:
        flash('Invalid status.', 'danger')
        return redirect(url_for('admin.view_submission', id=id))
    
    old_status = submission.status
    
    if old_status != new_status:
        submission.status = new_status
        submission.admin_notes = notes
        
        # Create status update record
        status_update = SubmissionStatusUpdate(
            submission_id=submission.id,
            old_status=old_status,
            new_status=new_status,
            notes=notes,
            updated_by_id=current_user.id
        )
        db.session.add(status_update)
        db.session.commit()
        
        # Send email notification
        try:
            send_submission_status_update(
                submission, old_status, new_status, notes,
                current_app.config['SITE_URL']
            )
        except Exception as e:
            current_app.logger.error(f"Failed to send status update email: {e}")
        
        status_display = new_status.replace('_', ' ').title()
        flash(f'Submission status updated to "{status_display}".', 'success')
    else:
        flash('No status change.', 'info')
    
    return redirect(url_for('admin.view_submission', id=id))


@admin_bp.route('/submissions/<int:id>/convert', methods=['GET', 'POST'])
def convert_to_article(id):
    """Convert an accepted submission to an article."""
    submission = Submission.query.get_or_404(id)
    
    if submission.status != 'accepted':
        flash('Only accepted submissions can be converted to articles.', 'warning')
        return redirect(url_for('admin.view_submission', id=id))
    
    journals = Journal.query.filter_by(is_active=True).order_by(Journal.name).all()
    all_tags = Tag.query.order_by(Tag.name).all()
    
    if request.method == 'POST':
        title = request.form.get('title', '').strip()
        abstract = request.form.get('abstract', '').strip()
        content = request.form.get('content', '').strip()
        authors = request.form.get('authors', '').strip()
        journal_id = request.form.get('journal_id', type=int)
        tag_ids = request.form.getlist('tags', type=int)
        is_open_access = request.form.get('is_open_access') == 'on'
        meta_keywords = request.form.get('meta_keywords', '').strip()
        
        if not title or not journal_id:
            flash('Title and Journal are required.', 'danger')
            return render_template('admin/submissions/convert.html',
                                 submission=submission,
                                 journals=journals,
                                 all_tags=all_tags)
        
        article = Article(
            title=title,
            slug=generate_unique_slug(title, Article),
            abstract=abstract,
            content=content,
            authors=authors,
            journal_id=journal_id,
            author_id=current_user.id,
            submission_id=submission.id,
            is_published=True,
            is_open_access=is_open_access,
            published_date=datetime.utcnow(),
            meta_title=title[:200],
            meta_description=abstract[:500] if abstract else '',
            meta_keywords=meta_keywords,
            pdf_file=submission.file_path  # Use the submission file
        )
        
        # Add tags
        if tag_ids:
            tags = Tag.query.filter(Tag.id.in_(tag_ids)).all()
            article.tags = tags
        
        db.session.add(article)
        db.session.commit()
        
        # Generate DOI
        article.doi = article.generate_doi()
        db.session.commit()
        
        flash(f'Article "{title}" created from submission.', 'success')
        return redirect(url_for('admin.articles'))
    
    return render_template('admin/submissions/convert.html',
                         submission=submission,
                         journals=journals,
                         all_tags=all_tags)


@admin_bp.route('/submissions/<int:id>/download')
def download_submission_file(id):
    """Download submission file."""
    submission = Submission.query.get_or_404(id)
    
    upload_folder = current_app.config['UPLOAD_FOLDER']
    file_path = os.path.dirname(submission.file_path)
    filename = os.path.basename(submission.file_path)
    
    return send_from_directory(
        os.path.join(upload_folder, file_path),
        filename,
        as_attachment=True
    )


# ==================== Contact Message Management ====================

@admin_bp.route('/messages')
def messages():
    """List all contact threads."""
    page = request.args.get('page', 1, type=int)
    status = request.args.get('status', '')
    
    query = ContactThread.query
    
    if status == 'open':
        query = query.filter_by(is_closed=False)
    elif status == 'closed':
        query = query.filter_by(is_closed=True)
    
    threads = query.order_by(ContactThread.updated_at.desc()).paginate(page=page, per_page=20, error_out=False)
    
    return render_template('admin/messages/list.html', threads=threads, current_status=status)


@admin_bp.route('/messages/<int:id>', methods=['GET', 'POST'])
def view_message(id):
    """View and reply to a contact thread."""
    thread = ContactThread.query.get_or_404(id)
    
    if request.method == 'POST':
        action = request.form.get('action', '')
        
        if action == 'reply':
            message_text = request.form.get('message', '').strip()
            
            if not message_text:
                flash('Reply message cannot be empty.', 'danger')
                return redirect(url_for('admin.view_message', id=id))
            
            message = ContactMessage(
                thread_id=thread.id,
                message=message_text,
                is_from_user=False,
                responder_id=current_user.id
            )
            db.session.add(message)
            thread.updated_at = datetime.utcnow()
            db.session.commit()
            
            # Send email notification to user
            try:
                send_contact_reply_notification(thread, message, current_app.config['SITE_URL'])
            except Exception as e:
                current_app.logger.error(f"Failed to send reply notification: {e}")
            
            flash('Reply sent successfully.', 'success')
        
        elif action == 'close':
            thread.is_closed = True
            db.session.commit()
            flash('Conversation closed.', 'info')
        
        elif action == 'reopen':
            thread.is_closed = False
            db.session.commit()
            flash('Conversation reopened.', 'info')
        
        return redirect(url_for('admin.view_message', id=id))
    
    messages = thread.messages.all()
    return render_template('admin/messages/view.html', thread=thread, messages=messages)


# ==================== Site Settings ====================

@admin_bp.route('/settings', methods=['GET', 'POST'])
def settings():
    """Edit site settings."""
    site_settings = SiteSettings.query.first()
    if not site_settings:
        site_settings = SiteSettings()
        db.session.add(site_settings)
        db.session.commit()
    
    if request.method == 'POST':
        # General settings
        site_settings.site_name = request.form.get('site_name', '').strip()
        site_settings.site_tagline = request.form.get('site_tagline', '').strip()
        site_settings.site_description = request.form.get('site_description', '').strip()
        site_settings.contact_email = request.form.get('contact_email', '').strip()
        
        # Homepage content
        site_settings.hero_title = request.form.get('hero_title', '').strip()
        site_settings.hero_subtitle = request.form.get('hero_subtitle', '').strip()
        site_settings.hero_cta_text = request.form.get('hero_cta_text', '').strip()
        site_settings.hero_cta_link = request.form.get('hero_cta_link', '').strip()
        
        # About section
        site_settings.about_title = request.form.get('about_title', '').strip()
        site_settings.about_content = request.form.get('about_content', '').strip()
        
        # Features
        site_settings.feature1_title = request.form.get('feature1_title', '').strip()
        site_settings.feature1_description = request.form.get('feature1_description', '').strip()
        site_settings.feature1_icon = request.form.get('feature1_icon', '').strip()
        
        site_settings.feature2_title = request.form.get('feature2_title', '').strip()
        site_settings.feature2_description = request.form.get('feature2_description', '').strip()
        site_settings.feature2_icon = request.form.get('feature2_icon', '').strip()
        
        site_settings.feature3_title = request.form.get('feature3_title', '').strip()
        site_settings.feature3_description = request.form.get('feature3_description', '').strip()
        site_settings.feature3_icon = request.form.get('feature3_icon', '').strip()
        
        # Footer and social
        site_settings.footer_text = request.form.get('footer_text', '').strip()
        site_settings.social_twitter = request.form.get('social_twitter', '').strip()
        site_settings.social_linkedin = request.form.get('social_linkedin', '').strip()
        site_settings.social_facebook = request.form.get('social_facebook', '').strip()
        
        # Analytics
        site_settings.google_analytics_id = request.form.get('google_analytics_id', '').strip()
        
        # Handle image uploads
        logo = request.files.get('site_logo')
        if logo and logo.filename and allowed_image(logo.filename):
            if site_settings.site_logo:
                delete_file(site_settings.site_logo)
            site_settings.site_logo = save_image(logo, 'site')
        
        favicon = request.files.get('site_favicon')
        if favicon and favicon.filename and allowed_image(favicon.filename):
            if site_settings.site_favicon:
                delete_file(site_settings.site_favicon)
            site_settings.site_favicon = save_image(favicon, 'site')
        
        hero_image = request.files.get('hero_image')
        if hero_image and hero_image.filename and allowed_image(hero_image.filename):
            if site_settings.hero_image:
                delete_file(site_settings.hero_image)
            site_settings.hero_image = save_image(hero_image, 'site')
        
        about_image = request.files.get('about_image')
        if about_image and about_image.filename and allowed_image(about_image.filename):
            if site_settings.about_image:
                delete_file(site_settings.about_image)
            site_settings.about_image = save_image(about_image, 'site')
        
        db.session.commit()
        flash('Site settings updated successfully.', 'success')
        return redirect(url_for('admin.settings'))
    
    return render_template('admin/settings/general.html', settings=site_settings)


# ==================== Content Blocks ====================

@admin_bp.route('/content')
def content_blocks():
    """List all content blocks."""
    blocks = ContentBlock.query.order_by(ContentBlock.page, ContentBlock.order).all()
    
    return render_template('admin/content/list.html', content_blocks=blocks)


@admin_bp.route('/content/add', methods=['GET', 'POST'])
def add_content_block():
    """Add a new content block."""
    if request.method == 'POST':
        page = request.form.get('page', '').strip()
        block_key = request.form.get('identifier', '').strip()  # Form uses 'identifier' field
        title = request.form.get('title', '').strip()
        content = request.form.get('content', '').strip()
        order = request.form.get('order', 0, type=int)
        is_active = request.form.get('is_active') == 'on'
        
        if not page or not block_key:
            flash('Page and Identifier are required.', 'danger')
            return render_template('admin/content/form.html', content_block=None)
        
        existing = ContentBlock.query.filter_by(page=page, block_key=block_key).first()
        if existing:
            flash('A content block with this page and identifier already exists.', 'danger')
            return render_template('admin/content/form.html', content_block=None)
        
        block = ContentBlock(
            page=page,
            block_key=block_key,
            title=title,
            content=content,
            order=order,
            is_active=is_active
        )
        
        # Handle image upload
        image = request.files.get('image')
        if image and image.filename and allowed_image(image.filename):
            block.image = save_image(image, 'content')
        
        db.session.add(block)
        db.session.commit()
        
        flash('Content block created successfully.', 'success')
        return redirect(url_for('admin.content_blocks'))
    
    return render_template('admin/content/form.html', content_block=None)


@admin_bp.route('/content/<int:id>/edit', methods=['GET', 'POST'])
def edit_content_block(id):
    """Edit a content block."""
    block = ContentBlock.query.get_or_404(id)
    
    if request.method == 'POST':
        block.title = request.form.get('title', '').strip()
        block.content = request.form.get('content', '').strip()
        block.order = request.form.get('order', 0, type=int)
        block.is_active = request.form.get('is_active') == 'on'
        
        # Handle image upload
        image = request.files.get('image')
        if image and image.filename and allowed_image(image.filename):
            if block.image:
                delete_file(block.image)
            block.image = save_image(image, 'content')
        
        db.session.commit()
        flash('Content block updated successfully.', 'success')
        return redirect(url_for('admin.content_blocks'))
    
    return render_template('admin/content/form.html', content_block=block)


@admin_bp.route('/content/<int:id>/delete', methods=['POST'])
def delete_content_block(id):
    """Delete a content block."""
    block = ContentBlock.query.get_or_404(id)
    
    if block.image:
        delete_file(block.image)
    
    db.session.delete(block)
    db.session.commit()
    flash('Content block deleted successfully.', 'success')
    return redirect(url_for('admin.content_blocks'))


# ==================== Image Management ====================

@admin_bp.route('/images')
def images():
    """List all uploaded images."""
    images = PageImage.query.order_by(PageImage.created_at.desc()).all()
    return render_template('admin/images/list.html', images=images)


@admin_bp.route('/images/upload', methods=['GET', 'POST'])
def upload_image():
    """Upload a new image."""
    if request.method == 'POST':
        name = request.form.get('name', '').strip()
        alt_text = request.form.get('alt_text', '').strip()
        page = request.form.get('page', '').strip()
        
        image_file = request.files.get('image')
        
        if not name:
            flash('Image name is required.', 'danger')
            return render_template('admin/images/upload.html')
        
        if not image_file or not image_file.filename:
            flash('Please select an image to upload.', 'danger')
            return render_template('admin/images/upload.html')
        
        if not allowed_image(image_file.filename):
            flash('Invalid image format. Allowed: PNG, JPG, JPEG, GIF, WEBP', 'danger')
            return render_template('admin/images/upload.html')
        
        filename = save_image(image_file, 'uploads')
        
        image = PageImage(
            name=name,
            filename=filename,
            alt_text=alt_text,
            page=page
        )
        db.session.add(image)
        db.session.commit()
        
        flash('Image uploaded successfully.', 'success')
        return redirect(url_for('admin.images'))
    
    return render_template('admin/images/upload.html')


@admin_bp.route('/images/<int:id>/edit', methods=['GET', 'POST'])
def edit_image(id):
    """Edit image metadata."""
    image = PageImage.query.get_or_404(id)
    
    if request.method == 'POST':
        image.name = request.form.get('name', '').strip()
        image.alt_text = request.form.get('alt_text', '').strip()
        image.page = request.form.get('page', '').strip()
        
        db.session.commit()
        flash('Image updated successfully.', 'success')
        return redirect(url_for('admin.images'))
    
    return render_template('admin/images/edit.html', image=image)


@admin_bp.route('/images/<int:id>/delete', methods=['POST'])
def delete_image(id):
    """Delete an image."""
    image = PageImage.query.get_or_404(id)
    
    delete_file(image.filename)
    
    db.session.delete(image)
    db.session.commit()
    flash('Image deleted successfully.', 'success')
    return redirect(url_for('admin.images'))