from flask import Blueprint, render_template, request, redirect, url_for, flash, jsonify, abort
from flask_login import login_required, current_user
from app.extensions import db
from app.models.society import SocietyProject, SocietyProjectSponsor, SocietyProjectLike, SocietyProjectComment
from app.models.user import User
from slugify import slugify
from datetime import datetime
from functools import wraps

society_bp = Blueprint("society", __name__, url_prefix="/society")


def premium_required(f):
    """Decorator to require premium subscription for route access."""
    @wraps(f)
    @login_required
    def decorated(*args, **kwargs):
        if not current_user.has_premium_access:
            flash("هذه الميزة متاحة فقط للمشتركين في الخطط المدفوعة", "warning")
            return redirect(url_for('subscription.plans'))
        return f(*args, **kwargs)
    return decorated


def _generate_unique_slug(title):
    """Generate a unique slug for a project."""
    base_slug = slugify(title, max_length=100)
    slug = base_slug
    counter = 1
    while SocietyProject.query.filter_by(slug=slug).first():
        slug = f"{base_slug}-{counter}"
        counter += 1
    return slug


@society_bp.route("/")
@premium_required
def index():
    """Browse all published society projects."""
    from sqlalchemy import func

    page = request.args.get("page", 1, type=int)
    search = request.args.get("q", "").strip()
    tier = request.args.get("tier", "").strip()
    sort = request.args.get("sort", "latest")

    query = SocietyProject.query.filter_by(status="published")

    # Search
    if search:
        query = query.filter(
            db.or_(
                SocietyProject.title.ilike(f"%{search}%"),
                SocietyProject.title_ar.ilike(f"%{search}%"),
                SocietyProject.description.ilike(f"%{search}%"),
                SocietyProject.description_ar.ilike(f"%{search}%")
            )
        )

    # Filter by sponsorship tier
    if tier:
        query = query.join(SocietyProject.sponsors).filter(
            SocietyProjectSponsor.tier == tier,
            SocietyProjectSponsor.status == "approved"
        )

    # Sorting
    if sort == "popular":
        query = query.order_by(SocietyProject.view_count.desc())
    elif sort == "sponsored":
        query = query.join(SocietyProject.sponsors).filter(
            SocietyProjectSponsor.status == "approved"
        ).distinct()
    else:  # latest
        query = query.order_by(SocietyProject.published_at.desc())

    pagination = query.paginate(page=page, per_page=12, error_out=False)

    # Get stats
    total_projects = SocietyProject.query.filter_by(status="published").count()
    total_sponsors = SocietyProjectSponsor.query.filter_by(status="approved").count()
    total_views = db.session.query(func.sum(SocietyProject.view_count)).filter_by(status="published").scalar() or 0
    total_likes = db.session.query(func.count(SocietyProjectLike.id)).join(
        SocietyProject, SocietyProjectLike.project_id == SocietyProject.id
    ).filter(SocietyProject.status == "published").scalar() or 0

    # Featured projects
    featured_projects = SocietyProject.query.filter_by(status="published", is_featured=True).limit(3).all()

    return render_template("society/index.html",
        pagination=pagination, search=search, tier=tier, sort=sort,
        total_projects=total_projects, total_sponsors=total_sponsors,
        total_views=total_views, total_likes=total_likes,
        featured_projects=featured_projects)


@society_bp.route("/<slug>")
def detail(slug):
    """View a single society project."""
    project = SocietyProject.query.filter_by(slug=slug, status="published").first_or_404()

    # Increment view count
    project.view_count += 1
    db.session.commit()

    # Check if user liked this project
    user_liked = False
    if current_user.is_authenticated:
        user_liked = SocietyProjectLike.query.filter_by(
            project_id=project.id, user_id=current_user.id
        ).first() is not None

    # Get comments
    comments = SocietyProjectComment.query.filter_by(
        project_id=project.id, parent_id=None, is_deleted=False
    ).order_by(SocietyProjectComment.created_at.desc()).all()

    return render_template("society/detail.html",
        project=project, user_liked=user_liked, comments=comments)


@society_bp.route("/submit", methods=["GET", "POST"])
@login_required
def submit():
    """Submit a new society project."""
    if request.method == "POST":
        title = request.form.get("title", "").strip()
        title_ar = request.form.get("title_ar", "").strip()
        description = request.form.get("description", "").strip()
        description_ar = request.form.get("description_ar", "").strip()
        content = request.form.get("content", "").strip()
        video_url = request.form.get("video_url", "").strip()
        cover_image = request.form.get("cover_image", "").strip()

        if not title:
            flash("العنوان مطلوب", "error")
            return redirect(url_for("society.submit"))

        # Create project
        project = SocietyProject(
            user_id=current_user.id,
            title=title,
            title_ar=title_ar or title,
            slug=_generate_unique_slug(title),
            description=description,
            description_ar=description_ar or description,
            content=content,
            video_url=video_url,
            cover_image=cover_image,
            status="pending"
        )

        # Handle file uploads (if any)
        if "pdf_file" in request.files:
            pdf_file = request.files["pdf_file"]
            if pdf_file and pdf_file.filename:
                # TODO: Upload to storage and save path
                pass

        db.session.add(project)
        db.session.commit()

        flash("تم إرسال مشروعك بنجاح! سيتم مراجعته من قبل الإدارة.", "success")
        return redirect(url_for("society.my_projects"))

    return render_template("society/submit.html")


@society_bp.route("/my-projects")
@login_required
def my_projects():
    """View user's own society projects."""
    from sqlalchemy import func

    page = request.args.get("page", 1, type=int)
    status_filter = request.args.get("status", "")

    query = SocietyProject.query.filter_by(user_id=current_user.id)

    if status_filter:
        query = query.filter_by(status=status_filter)

    pagination = query.order_by(SocietyProject.created_at.desc()).paginate(
        page=page, per_page=10, error_out=False
    )

    # Get stats
    total_projects = query.count()
    pending_count = SocietyProject.query.filter_by(user_id=current_user.id, status="pending").count()
    published_count = SocietyProject.query.filter_by(user_id=current_user.id, status="published").count()

    # Calculate total sponsorship
    total_sponsorship = db.session.query(func.sum(SocietyProjectSponsor.monthly_contribution)).join(
        SocietyProject, SocietyProjectSponsor.project_id == SocietyProject.id
    ).filter(
        SocietyProject.user_id == current_user.id,
        SocietyProjectSponsor.status == "approved"
    ).scalar() or 0

    return render_template("society/my_projects.html",
        pagination=pagination, status_filter=status_filter,
        total_projects=total_projects, pending_count=pending_count,
        published_count=published_count, total_sponsorship=total_sponsorship)


@society_bp.route("/<int:project_id>/like", methods=["POST"])
@login_required
def like_project(project_id):
    """Like/unlike a project."""
    project = SocietyProject.query.get_or_404(project_id)

    existing_like = SocietyProjectLike.query.filter_by(
        project_id=project_id, user_id=current_user.id
    ).first()

    if existing_like:
        db.session.delete(existing_like)
        liked = False
    else:
        like = SocietyProjectLike(project_id=project_id, user_id=current_user.id)
        db.session.add(like)
        liked = True

    db.session.commit()

    return jsonify({"liked": liked, "count": project.like_count})


@society_bp.route("/<slug>/sponsor-request", methods=["POST"])
@login_required
def sponsor_request(slug):
    """Submit a sponsorship request for a project."""
    project = SocietyProject.query.filter_by(slug=slug, status="published").first_or_404()

    # Check if user already has a pending/approved sponsorship
    existing = SocietyProjectSponsor.query.filter_by(
        project_id=project.id, sponsor_id=current_user.id
    ).filter(
        db.or_(
            SocietyProjectSponsor.status == "pending",
            SocietyProjectSponsor.status == "approved"
        )
    ).first()

    if existing:
        return jsonify({"error": "لديك بالفعل طلب رعاية لهذا المشروع"}), 400

    tier = request.form.get("tier", "bronze")
    monthly_contribution = request.form.get("monthly_contribution")
    logo_url = request.form.get("logo_url", "").strip()
    website_url = request.form.get("website_url", "").strip()
    notes = request.form.get("notes", "").strip()

    # Determine sponsor type based on user role
    sponsor_type = "individual"
    if current_user.role == "factory":
        sponsor_type = "factory"
    elif hasattr(current_user, "is_investor") and current_user.is_investor:
        sponsor_type = "investor"

    sponsorship = SocietyProjectSponsor(
        project_id=project.id,
        sponsor_id=current_user.id,
        sponsor_type=sponsor_type,
        tier=tier,
        logo_url=logo_url,
        website_url=website_url,
        monthly_contribution=float(monthly_contribution) if monthly_contribution else None,
        notes=notes,
        status="pending"
    )

    db.session.add(sponsorship)
    db.session.commit()

    flash("تم إرسال طلب الرعاية بنجاح! سيتم مراجعته من قبل الإدارة.", "success")
    return redirect(url_for("society.detail", slug=slug))


@society_bp.route("/<int:project_id>/comment", methods=["POST"])
@login_required
def add_comment(project_id):
    """Add a comment to a project."""
    project = SocietyProject.query.get_or_404(project_id)
    content = request.form.get("content", "").strip()

    if not content:
        return jsonify({"error": "التعليق مطلوب"}), 400

    parent_id = request.form.get("parent_id", type=int)

    comment = SocietyProjectComment(
        project_id=project_id,
        user_id=current_user.id,
        parent_id=parent_id,
        content=content
    )

    db.session.add(comment)
    db.session.commit()

    return jsonify({
        "success": True,
        "comment_id": comment.id,
        "content": content,
        "user_name": current_user.name,
        "created_at": comment.created_at.strftime("%Y-%m-%d %H:%M")
    })


@society_bp.route("/<int:project_id>/notebooklm-import", methods=["POST"])
@login_required
def import_notebooklm(project_id):
    """Import NotebookLM data to user's own project."""
    project = SocietyProject.query.get_or_404(project_id)

    # Only project owner can import
    if project.user_id != current_user.id:
        return jsonify({"error": "غير مصرح"}), 403

    report_id = request.form.get("report_id", type=int)

    # Import from report
    from app.models.report import Report
    report = Report.query.get_or_404(report_id)

    if report.user_id != current_user.id:
        return jsonify({"error": "التقرير ليس ملكك"}), 403

    # Import NotebookLM data
    project.notebooklm_data = {
        "report_id": report.id,
        "project_name": report.project_name,
        "verdict": report.verdict,
        "ai_summary": report.ai_summary if hasattr(report, 'ai_summary') else None,
        "key_points": report.key_points_json if hasattr(report, 'key_points_json') else []
    }

    db.session.commit()

    return jsonify({"success": True, "message": "تم استيراد بيانات NotebookLM بنجاح"})