from functools import wraps
from flask import Blueprint, render_template, redirect, url_for, flash, request, jsonify
from flask_login import login_required, current_user
from app.extensions import db
from app.models.user import User
from app.models.report import Report
from app.models.subscription import Plan, Subscription

admin_bp = Blueprint("admin", __name__, url_prefix="/admin")


def admin_required(f):
    @wraps(f)
    @login_required
    def decorated(*args, **kwargs):
        if not current_user.is_admin:
            flash("Access denied.", "error")
            return redirect(url_for("dashboard.index"))
        return f(*args, **kwargs)
    return decorated


@admin_bp.route("/")
@admin_required
def index():
    users_count = User.query.count()
    reports_count = Report.query.count()
    subs_count = Subscription.query.filter_by(status="active").count()
    recent_users = User.query.order_by(User.created_at.desc()).limit(10).all()
    recent_reports = Report.query.order_by(Report.created_at.desc()).limit(10).all()
    return render_template("admin/index.html",
        users_count=users_count, reports_count=reports_count,
        subs_count=subs_count, recent_users=recent_users,
        recent_reports=recent_reports)


@admin_bp.route("/users")
@admin_required
def users():
    page = request.args.get("page", 1, type=int)
    q = request.args.get("q", "").strip()
    query = User.query
    if q:
        query = query.filter(User.email.ilike(f"%{q}%") | User.name.ilike(f"%{q}%"))
    pagination = query.order_by(User.created_at.desc()).paginate(page=page, per_page=20, error_out=False)
    return render_template("admin/users.html", pagination=pagination, q=q)


@admin_bp.route("/users/<int:user_id>/toggle-admin", methods=["POST"])
@admin_required
def toggle_admin(user_id):
    user = User.query.get_or_404(user_id)
    if user.id == current_user.id:
        flash("Cannot change your own admin status.", "error")
    else:
        user.is_admin = not user.is_admin
        db.session.commit()
        flash(f"{'Granted' if user.is_admin else 'Revoked'} admin for {user.email}.", "success")
    return redirect(url_for("admin.users"))


@admin_bp.route("/reports")
@admin_required
def reports():
    page = request.args.get("page", 1, type=int)
    pagination = Report.query.order_by(Report.created_at.desc()).paginate(page=page, per_page=20, error_out=False)
    return render_template("admin/reports.html", pagination=pagination)


@admin_bp.route("/analytics")
@admin_required
def analytics():
    from datetime import datetime, timedelta
    from sqlalchemy import func

    total_users = User.query.count()
    total_reports = Report.query.count()
    active_subs = Subscription.query.filter_by(status="active").all()

    mrr = sum(float(s.plan.price_monthly) for s in active_subs if s.plan)
    arr = mrr * 12
    pro_count = sum(1 for s in active_subs if s.plan and s.plan.name == "pro")
    enterprise_count = sum(1 for s in active_subs if s.plan and s.plan.name == "enterprise")
    free_count = total_users - pro_count - enterprise_count
    conversion_rate = round(((pro_count + enterprise_count) / total_users * 100), 1) if total_users > 0 else 0
    avg_revenue_per_user = round(mrr / total_users, 2) if total_users > 0 else 0

    now = datetime.utcnow()
    months_data = []
    for i in range(5, -1, -1):
        d = now.replace(day=1) - timedelta(days=i * 30)
        start = d.replace(day=1, hour=0, minute=0, second=0)
        if i > 0:
            end = (start + timedelta(days=32)).replace(day=1)
        else:
            end = now
        users_m = User.query.filter(User.created_at >= start, User.created_at < end).count()
        reports_m = Report.query.filter(Report.created_at >= start, Report.created_at < end).count()
        months_data.append({
            "label": start.strftime("%b %Y"),
            "users": users_m,
            "reports": reports_m,
        })

    from app.models.features import AuditLog
    recent_logs = AuditLog.query.order_by(AuditLog.created_at.desc()).limit(20).all()

    return render_template("admin/analytics.html",
        total_users=total_users, total_reports=total_reports,
        mrr=mrr, arr=arr, pro_count=pro_count, enterprise_count=enterprise_count,
        free_count=free_count, months_data=months_data, recent_logs=recent_logs,
        conversion_rate=conversion_rate, avg_revenue_per_user=avg_revenue_per_user)


@admin_bp.route("/audit")
@admin_required
def audit():
    from app.models.features import AuditLog
    page = request.args.get("page", 1, type=int)
    q = request.args.get("q", "").strip()
    query = AuditLog.query
    if q:
        query = query.filter(AuditLog.action.ilike(f"%{q}%"))
    pagination = query.order_by(AuditLog.created_at.desc()).paginate(page=page, per_page=50, error_out=False)
    return render_template("admin/audit.html", pagination=pagination, q=q)


@admin_bp.route("/users/<int:user_id>/set-plan", methods=["POST"])
@admin_required
def set_plan(user_id):
    user = User.query.get_or_404(user_id)
    plan_name = request.form.get("plan_name", "").strip()
    plan = Plan.query.filter_by(name=plan_name).first()
    if not plan:
        flash(f"Plan '{plan_name}' not found.", "error")
        return redirect(url_for("admin.users"))
    sub = Subscription.query.filter_by(user_id=user.id).first()
    if sub:
        sub.plan_id = plan.id
        sub.status = "active"
    else:
        sub = Subscription(user_id=user.id, plan_id=plan.id, status="active")
        db.session.add(sub)
    db.session.commit()
    flash(f"تم تغيير اشتراك {user.email} إلى {plan.display_name}.", "success")
    return redirect(url_for("admin.users"))


@admin_bp.route("/users/<int:user_id>/set-video-provider", methods=["POST"])
@admin_required
def set_video_provider(user_id):
    user = User.query.get_or_404(user_id)
    provider = request.form.get("video_provider", "").strip()
    if provider == "plan_default":
        user.video_provider = None
    elif provider in ("sora", "veo", "kling", "runway", "pika", "fal", "none"):
        user.video_provider = provider
    db.session.commit()
    flash(f"تم تحديث مزود الفيديو لـ {user.name}.", "success")
    return redirect(url_for("admin.users"))


@admin_bp.route("/plans")
@admin_required
def plans():
    all_plans = Plan.query.order_by(Plan.id).all()
    return render_template("admin/plans.html", plans=all_plans)


@admin_bp.route("/plans/<int:plan_id>/set-video-provider", methods=["POST"])
@admin_required
def set_plan_video_provider(plan_id):
    plan = Plan.query.get_or_404(plan_id)
    provider = request.form.get("video_provider", "sora").strip()
    if provider in ("sora", "veo", "kling", "runway", "pika", "fal", "none"):
        plan.video_provider = provider
        db.session.commit()
        flash(f"تم تحديث مزود الفيديو لخطة {plan.display_name}.", "success")
    return redirect(url_for("admin.plans"))


@admin_bp.route("/ai-config")
@admin_required
def ai_config():
    from app.models.features import AIModelConfig
    configs = AIModelConfig.query.order_by(AIModelConfig.screen_name, AIModelConfig.plan_name).all()
    from flask import current_app
    return render_template("admin/ai_config.html",
        configs=configs,
        screen_choices=AIModelConfig.SCREEN_CHOICES,
        provider_choices=AIModelConfig.PROVIDER_CHOICES,
        default_provider=current_app.config.get("AI_PROVIDER", "openai"),
        default_fast=current_app.config.get("FAST_MODEL", "gpt-4o-mini"),
        default_deep=current_app.config.get("DEEP_MODEL", "gpt-4o"))


@admin_bp.route("/ai-config/add", methods=["POST"])
@admin_required
def add_ai_config():
    from app.models.features import AIModelConfig
    screen_name = request.form.get("screen_name", "").strip()
    plan_name = request.form.get("plan_name", "").strip()
    provider = request.form.get("provider", "openai").strip()
    model_name = request.form.get("model_name", "").strip()
    max_tokens = request.form.get("max_tokens", 16384, type=int)
    temperature = request.form.get("temperature", 0.7, type=float)
    api_key_override = request.form.get("api_key_override", "").strip() or None

    if not screen_name or not plan_name or not model_name:
        flash("جميع الحقول مطلوبة.", "error")
        return redirect(url_for("admin.ai_config"))

    existing = AIModelConfig.query.filter_by(screen_name=screen_name, plan_name=plan_name).first()
    if existing:
        existing.provider = provider
        existing.model_name = model_name
        existing.max_tokens = max_tokens
        existing.temperature = temperature
        existing.api_key_override = api_key_override
        existing.is_active = True
        flash("تم تحديث الإعداد.", "success")
    else:
        config = AIModelConfig(
            screen_name=screen_name, plan_name=plan_name,
            provider=provider, model_name=model_name,
            max_tokens=max_tokens, temperature=temperature,
            api_key_override=api_key_override)
        db.session.add(config)
        flash("تم إضافة الإعداد.", "success")
    db.session.commit()
    return redirect(url_for("admin.ai_config"))


@admin_bp.route("/ai-config/toggle/<int:config_id>", methods=["POST"])
@admin_required
def toggle_ai_config(config_id):
    from app.models.features import AIModelConfig
    config = AIModelConfig.query.get_or_404(config_id)
    config.is_active = not config.is_active
    db.session.commit()
    flash(f"{'تم تفعيل' if config.is_active else 'تم تعطيل'} الإعداد.", "success")
    return redirect(url_for("admin.ai_config"))


@admin_bp.route("/ai-config/delete/<int:config_id>", methods=["POST"])
@admin_required
def delete_ai_config(config_id):
    from app.models.features import AIModelConfig
    config = AIModelConfig.query.get_or_404(config_id)
    db.session.delete(config)
    db.session.commit()
    flash("تم حذف الإعداد.", "success")
    return redirect(url_for("admin.ai_config"))


# ── System Prompts Management ──

@admin_bp.route("/prompts")
@admin_required
def prompts():
    from app.models.features import SystemPrompt
    all_prompts = SystemPrompt.query.order_by(SystemPrompt.service_key).all()
    return render_template("admin/prompts.html",
        prompts=all_prompts,
        service_choices=SystemPrompt.SERVICE_CHOICES)


@admin_bp.route("/prompts/save", methods=["POST"])
@admin_required
def save_prompt():
    from app.models.features import SystemPrompt
    service_key = request.form.get("service_key", "").strip()
    display_name = request.form.get("display_name", "").strip()
    system_prompt = request.form.get("system_prompt", "").strip()
    user_prompt_template = request.form.get("user_prompt_template", "").strip() or None

    if not service_key or not system_prompt:
        flash("مفتاح الخدمة والبرومبت مطلوبان.", "error")
        return redirect(url_for("admin.prompts"))

    if not display_name:
        for k, v in SystemPrompt.SERVICE_CHOICES:
            if k == service_key:
                display_name = v
                break
        else:
            display_name = service_key

    existing = SystemPrompt.query.filter_by(service_key=service_key).first()
    if existing:
        existing.display_name = display_name
        existing.system_prompt = system_prompt
        existing.user_prompt_template = user_prompt_template
        existing.is_active = True
        existing.updated_by = current_user.id
        flash(f"تم تحديث برومبت «{display_name}».", "success")
    else:
        p = SystemPrompt(
            service_key=service_key,
            display_name=display_name,
            system_prompt=system_prompt,
            user_prompt_template=user_prompt_template,
            updated_by=current_user.id,
        )
        db.session.add(p)
        flash(f"تم إضافة برومبت «{display_name}».", "success")
    db.session.commit()
    return redirect(url_for("admin.prompts"))


@admin_bp.route("/prompts/toggle/<int:prompt_id>", methods=["POST"])
@admin_required
def toggle_prompt(prompt_id):
    from app.models.features import SystemPrompt
    p = SystemPrompt.query.get_or_404(prompt_id)
    p.is_active = not p.is_active
    db.session.commit()
    flash(f"{'تم تفعيل' if p.is_active else 'تم تعطيل'} برومبت «{p.display_name}».", "success")
    return redirect(url_for("admin.prompts"))


@admin_bp.route("/prompts/delete/<int:prompt_id>", methods=["POST"])
@admin_required
def delete_prompt(prompt_id):
    from app.models.features import SystemPrompt
    p = SystemPrompt.query.get_or_404(prompt_id)
    db.session.delete(p)
    db.session.commit()
    flash("تم حذف البرومبت.", "success")
    return redirect(url_for("admin.prompts"))


@admin_bp.route("/prompts/default/<service_key>")
@admin_required
def get_default_prompt(service_key):
    """Return the hardcoded default prompt for a service (for reference)."""
    defaults = _get_default_prompts()
    data = defaults.get(service_key, {"system": "", "user": ""})
    return jsonify(data)


def _get_default_prompts():
    """Collect hardcoded default prompts from code for admin reference."""
    from app.ai.prompts.market_logic import get_market_logic_prompt
    from app.ai.prompts.financial import get_financial_prompt
    from app.ai.prompts.competitive import get_competitive_prompt
    from app.ai.prompts.synthesis import get_synthesis_prompt

    defaults = {}
    # Extract system and user messages from each prompt function
    for key, fn, args in [
        ("market_logic", get_market_logic_prompt, ("PROJECT_NAME", "PROJECT_DESC", "ar")),
        ("financial", get_financial_prompt, ("PROJECT_NAME", "PROJECT_DESC", "ar")),
        ("competitive", get_competitive_prompt, ("PROJECT_NAME", "PROJECT_DESC", "ar")),
    ]:
        try:
            msgs = fn(*args)
            defaults[key] = {
                "system": next((m["content"] for m in msgs if m["role"] == "system"), ""),
                "user": next((m["content"] for m in msgs if m["role"] == "user"), ""),
            }
        except Exception:
            defaults[key] = {"system": "", "user": ""}

    try:
        msgs = get_synthesis_prompt("PROJECT_NAME", "PROJECT_DESC", "", "", "", "ar")
        defaults["synthesis"] = {
            "system": next((m["content"] for m in msgs if m["role"] == "system"), ""),
            "user": next((m["content"] for m in msgs if m["role"] == "user"), ""),
        }
    except Exception:
        defaults["synthesis"] = {"system": "", "user": ""}

    return defaults


# ── Video Provider Config Management ──

@admin_bp.route("/video-providers")
@admin_required
def video_providers():
    from app.models.features import VideoProviderConfig
    configs = VideoProviderConfig.query.order_by(VideoProviderConfig.provider_name).all()
    configs_map = {c.provider_name: c for c in configs}
    all_plans = Plan.query.order_by(Plan.id).all()
    return render_template("admin/video_providers.html",
        configs=configs, configs_map=configs_map,
        provider_defs=VideoProviderConfig.PROVIDER_DEFS,
        plans=all_plans)


@admin_bp.route("/video-providers/save", methods=["POST"])
@admin_required
def save_video_provider():
    from app.models.features import VideoProviderConfig
    provider_name = request.form.get("provider_name", "").strip()
    display_name = request.form.get("display_name", "").strip()
    api_key = request.form.get("api_key", "").strip() or None
    api_secret = request.form.get("api_secret", "").strip() or None
    is_active = request.form.get("is_active") == "1"
    notes = request.form.get("notes", "").strip() or None

    if not provider_name:
        flash("اسم المزود مطلوب.", "error")
        return redirect(url_for("admin.video_providers"))

    # Parse allowed durations from form checkboxes
    allowed_durations = request.form.getlist("allowed_durations")
    allowed_durations = [int(d) for d in allowed_durations if d.isdigit()]

    existing = VideoProviderConfig.query.filter_by(provider_name=provider_name).first()
    if existing:
        if api_key:
            existing.api_key = api_key
        if api_secret is not None:
            existing.api_secret = api_secret
        existing.is_active = is_active
        if display_name:
            existing.display_name = display_name
        if notes is not None:
            existing.notes = notes
        # Merge allowed_durations into extra_config
        extra = existing.extra_config or {}
        if not isinstance(extra, dict):
            extra = {}
        if allowed_durations:
            extra["allowed_durations"] = sorted(allowed_durations)
        else:
            extra.pop("allowed_durations", None)
        existing.extra_config = extra
        existing.updated_by = current_user.id
        flash(f"تم تحديث إعدادات {existing.display_name}.", "success")
    else:
        if not display_name:
            for pdef in VideoProviderConfig.PROVIDER_DEFS:
                if pdef["name"] == provider_name:
                    display_name = pdef["display"]
                    break
            else:
                display_name = provider_name
        extra_config = {}
        if allowed_durations:
            extra_config["allowed_durations"] = sorted(allowed_durations)
        cfg = VideoProviderConfig(
            provider_name=provider_name,
            display_name=display_name,
            api_key=api_key,
            api_secret=api_secret,
            is_active=is_active,
            notes=notes,
            extra_config=extra_config or None,
            updated_by=current_user.id,
        )
        db.session.add(cfg)
        flash(f"تم إضافة مزود {display_name}.", "success")
    db.session.commit()
    return redirect(url_for("admin.video_providers"))


@admin_bp.route("/video-providers/toggle/<int:config_id>", methods=["POST"])
@admin_required
def toggle_video_provider(config_id):
    from app.models.features import VideoProviderConfig
    cfg = VideoProviderConfig.query.get_or_404(config_id)
    cfg.is_active = not cfg.is_active
    cfg.updated_by = current_user.id
    db.session.commit()
    status = "تم تفعيل" if cfg.is_active else "تم تعطيل"
    flash(f"{status} مزود {cfg.display_name}.", "success")
    return redirect(url_for("admin.video_providers"))


@admin_bp.route("/video-providers/delete/<int:config_id>", methods=["POST"])
@admin_required
def delete_video_provider(config_id):
    from app.models.features import VideoProviderConfig
    cfg = VideoProviderConfig.query.get_or_404(config_id)
    name = cfg.display_name
    db.session.delete(cfg)
    db.session.commit()
    flash(f"تم حذف مزود {name}.", "success")
    return redirect(url_for("admin.video_providers"))


@admin_bp.route("/video-providers/assign-plan", methods=["POST"])
@admin_required
def assign_plan_video_provider():
    plan_id = request.form.get("plan_id", 0, type=int)
    provider = request.form.get("video_provider", "sora").strip()
    plan = Plan.query.get_or_404(plan_id)
    from app.ai.video_providers import VALID_PROVIDERS
    if provider in VALID_PROVIDERS:
        plan.video_provider = provider
        db.session.commit()
        flash(f"تم تعيين {provider} لخطة {plan.display_name}.", "success")
    return redirect(url_for("admin.video_providers"))


# ══════════════════════════════════════════════════════════════
#  Marketplace Review — Admin Routes
# ══════════════════════════════════════════════════════════════

@admin_bp.route("/marketplace")
@admin_required
def marketplace_review():
    from app.models.features import MarketplaceListing, MarketplacePurchase
    status_filter = request.args.get("status", "pending")
    query = MarketplaceListing.query
    if status_filter:
        query = query.filter_by(approval_status=status_filter)
    listings = query.order_by(MarketplaceListing.created_at.desc()).all()

    total_sales = MarketplacePurchase.query.filter_by(status="completed").count()
    total_revenue = db.session.query(db.func.coalesce(db.func.sum(MarketplacePurchase.amount), 0)).filter_by(status="completed").scalar()
    pending_count = MarketplaceListing.query.filter_by(approval_status="pending").count()

    return render_template("admin/marketplace_review.html",
        listings=listings, status_filter=status_filter,
        total_sales=total_sales, total_revenue=total_revenue,
        pending_count=pending_count)


@admin_bp.route("/marketplace/<int:listing_id>/approve", methods=["POST"])
@admin_required
def marketplace_approve(listing_id):
    from app.models.features import MarketplaceListing, Notification
    listing = MarketplaceListing.query.get_or_404(listing_id)
    listing.approval_status = "approved"
    listing.is_active = True
    db.session.commit()

    notif = Notification(
        user_id=listing.user_id,
        title="تمت الموافقة على دراستك ✅",
        message=f"دراسة «{listing.title}» أصبحت متاحة الآن في السوق.",
        category="marketplace",
        link=url_for("marketplace.view_listing", listing_id=listing.id),
    )
    db.session.add(notif)
    db.session.commit()
    flash(f"تمت الموافقة على «{listing.title}».", "success")
    return redirect(url_for("admin.marketplace_review"))


@admin_bp.route("/marketplace/<int:listing_id>/reject", methods=["POST"])
@admin_required
def marketplace_reject(listing_id):
    from app.models.features import MarketplaceListing, Notification
    listing = MarketplaceListing.query.get_or_404(listing_id)
    listing.approval_status = "rejected"
    listing.is_active = False
    listing.admin_notes = request.form.get("admin_notes", "").strip()
    db.session.commit()

    notif = Notification(
        user_id=listing.user_id,
        title="تم رفض دراستك في السوق",
        message=f"دراسة «{listing.title}» لم تتم الموافقة عليها. {listing.admin_notes or ''}",
        category="marketplace",
        link=url_for("marketplace.my_listings"),
    )
    db.session.add(notif)
    db.session.commit()
    flash(f"تم رفض «{listing.title}».", "success")
    return redirect(url_for("admin.marketplace_review"))


@admin_bp.route("/marketplace/<int:listing_id>/feature", methods=["POST"])
@admin_required
def marketplace_feature(listing_id):
    from app.models.features import MarketplaceListing
    listing = MarketplaceListing.query.get_or_404(listing_id)
    listing.featured = not listing.featured
    db.session.commit()
    status = "تم تمييز" if listing.featured else "تم إلغاء تمييز"
    flash(f"{status} «{listing.title}».", "success")
    return redirect(url_for("admin.marketplace_review", status="approved"))


# ══════════════════════════════════════════════════════════════
#  Factory & IP Admin Routes
# ══════════════════════════════════════════════════════════════

@admin_bp.route("/factories")
@admin_required
def admin_factories():
    from app.models.services import FactoryPartner
    factories = FactoryPartner.query.order_by(FactoryPartner.created_at.desc()).all()
    return render_template("admin/factories.html", factories=factories)


@admin_bp.route("/factories/toggle/<int:fid>", methods=["POST"])
@admin_required
def toggle_factory(fid):
    from app.models.services import FactoryPartner
    f = FactoryPartner.query.get_or_404(fid)
    f.is_active = not f.is_active
    db.session.commit()
    flash(f"{'تم تفعيل' if f.is_active else 'تم تعطيل'} المصنع «{f.name_ar or f.name}».", "success")
    return redirect(url_for("admin.admin_factories"))


@admin_bp.route("/factories/verify/<int:fid>", methods=["POST"])
@admin_required
def verify_factory(fid):
    from app.models.services import FactoryPartner
    f = FactoryPartner.query.get_or_404(fid)
    f.is_verified = not f.is_verified
    db.session.commit()
    flash(f"{'تم توثيق' if f.is_verified else 'تم إلغاء توثيق'} المصنع.", "success")
    return redirect(url_for("admin.admin_factories"))


@admin_bp.route("/ip-applications")
@admin_required
def admin_ip():
    from app.models.services import PatentApplication, TrademarkApplication
    patents = PatentApplication.query.order_by(PatentApplication.created_at.desc()).all()
    trademarks = TrademarkApplication.query.order_by(TrademarkApplication.created_at.desc()).all()
    return render_template("admin/ip_review.html", patents=patents, trademarks=trademarks)


@admin_bp.route("/prototype-requests")
@admin_required
def admin_prototypes():
    from app.models.services import PrototypeRequest
    reqs = PrototypeRequest.query.order_by(PrototypeRequest.created_at.desc()).all()
    return render_template("admin/prototype_requests.html", requests=reqs)


@admin_bp.route("/prototype-requests/<int:req_id>")
@admin_required
def admin_prototype_detail(req_id):
    from app.models.services import PrototypeRequest
    proto = PrototypeRequest.query.get_or_404(req_id)
    return render_template("admin/prototype_detail.html", proto=proto)


@admin_bp.route("/notify-user", methods=["POST"])
@admin_required
def admin_notify_user():
    """Admin sends a notification to a specific user about a project."""
    from app.routes.notifications import notify
    user_id = request.form.get("user_id", type=int)
    title = request.form.get("title", "").strip()
    message = request.form.get("message", "").strip()
    link = request.form.get("link", "").strip() or None
    if user_id and title:
        notify(user_id, title, message, category="admin", link=link)
        flash("تم إرسال التنبيه بنجاح", "success")
    else:
        flash("بيانات غير مكتملة", "error")
    return redirect(request.referrer or url_for("admin.admin_prototypes"))


# ══════════════════════════════════════════════════════════════
#  Ad Campaign Management — Admin Routes
# ══════════════════════════════════════════════════════════════

from app.models.ads import (
    AdminAdAccount, AdBudgetWallet, UserAdBudget,
    AdCampaign, AdCampaignMetrics, AdAuditLog,
    SponsorSocialAccount,
)


# ── 1. Ad Accounts Management ──

@admin_bp.route("/ad-accounts")
@admin_required
def ad_accounts():
    accounts = AdminAdAccount.query.order_by(AdminAdAccount.platform).all()
    wallet = AdBudgetWallet.query.first()
    return render_template("admin/ad_accounts.html", accounts=accounts, wallet=wallet)


@admin_bp.route("/ad-accounts/save", methods=["POST"])
@admin_required
def save_ad_account():
    platform = request.form.get("platform", "").strip()
    account_id = request.form.get("account_id", "").strip()
    access_token = request.form.get("access_token", "").strip()
    refresh_token = request.form.get("refresh_token", "").strip() or None
    daily_spend_limit = request.form.get("daily_spend_limit", 0, type=float)
    total_deposited = request.form.get("total_deposited", 0, type=float)
    notes = request.form.get("notes", "").strip() or None
    is_active = request.form.get("is_active") == "1"

    if not platform:
        flash("المنصة مطلوبة.", "error")
        return redirect(url_for("admin.ad_accounts"))

    existing = AdminAdAccount.query.filter_by(platform=platform).first()
    if existing:
        if account_id:
            existing.account_id = account_id
        if access_token:
            existing.access_token = access_token
        if refresh_token is not None:
            existing.refresh_token = refresh_token
        existing.daily_spend_limit = daily_spend_limit
        existing.total_deposited = total_deposited
        existing.is_active = is_active
        existing.notes = notes
        existing.updated_by = current_user.id
        flash(f"تم تحديث حساب {platform}.", "success")
    else:
        acc = AdminAdAccount(
            platform=platform, account_id=account_id,
            access_token=access_token, refresh_token=refresh_token,
            daily_spend_limit=daily_spend_limit, total_deposited=total_deposited,
            is_active=is_active, notes=notes, updated_by=current_user.id,
        )
        db.session.add(acc)
        flash(f"تم إضافة حساب {platform}.", "success")
    db.session.commit()
    return redirect(url_for("admin.ad_accounts"))


@admin_bp.route("/ad-accounts/toggle/<int:account_id>", methods=["POST"])
@admin_required
def toggle_ad_account(account_id):
    acc = AdminAdAccount.query.get_or_404(account_id)
    acc.is_active = not acc.is_active
    acc.updated_by = current_user.id
    db.session.commit()
    flash(f"{'تم تفعيل' if acc.is_active else 'تم تعطيل'} حساب {acc.platform}.", "success")
    return redirect(url_for("admin.ad_accounts"))


@admin_bp.route("/ad-accounts/delete/<int:account_id>", methods=["POST"])
@admin_required
def delete_ad_account(account_id):
    acc = AdminAdAccount.query.get_or_404(account_id)
    name = acc.platform
    db.session.delete(acc)
    db.session.commit()
    flash(f"تم حذف حساب {name}.", "success")
    return redirect(url_for("admin.ad_accounts"))


@admin_bp.route("/ad-wallet/save", methods=["POST"])
@admin_required
def save_ad_wallet():
    total_budget = request.form.get("total_budget", 0, type=float)
    currency = request.form.get("currency", "USD").strip()
    wallet = AdBudgetWallet.query.first()
    if wallet:
        wallet.total_budget = total_budget
        wallet.currency = currency
        wallet.updated_by = current_user.id
    else:
        wallet = AdBudgetWallet(
            total_budget=total_budget, currency=currency,
            updated_by=current_user.id,
        )
        db.session.add(wallet)
    db.session.commit()
    flash("تم تحديث محفظة الميزانية.", "success")
    return redirect(url_for("admin.ad_accounts"))


# ── 2. User Ad Budgets Management ──

@admin_bp.route("/ad-budgets")
@admin_required
def ad_budgets():
    users = User.query.order_by(User.created_at.desc()).all()
    budgets = {b.user_id: b for b in UserAdBudget.query.all()}
    wallet = AdBudgetWallet.query.first()
    total_allocated = sum(b.allocated_budget for b in budgets.values())
    return render_template("admin/ad_budgets.html",
        users=users, budgets=budgets, wallet=wallet, total_allocated=total_allocated)


@admin_bp.route("/ad-budgets/save", methods=["POST"])
@admin_required
def save_ad_budget():
    user_id = request.form.get("user_id", 0, type=int)
    allocated_budget = request.form.get("allocated_budget", 0, type=float)
    is_active = request.form.get("is_active") == "1"

    user = User.query.get_or_404(user_id)
    budget = UserAdBudget.query.filter_by(user_id=user_id).first()
    if budget:
        budget.allocated_budget = allocated_budget
        budget.is_active = is_active
        budget.set_by_admin_id = current_user.id
    else:
        budget = UserAdBudget(
            user_id=user_id, allocated_budget=allocated_budget,
            is_active=is_active, set_by_admin_id=current_user.id,
        )
        db.session.add(budget)

    # Log
    log = AdAuditLog(
        admin_id=current_user.id, user_id=user_id,
        action="budget_changed",
        details_json={"allocated_budget": allocated_budget, "is_active": is_active},
    )
    db.session.add(log)
    db.session.commit()
    flash(f"تم تحديث ميزانية {user.name}.", "success")
    return redirect(url_for("admin.ad_budgets"))


@admin_bp.route("/ad-budgets/toggle/<int:user_id>", methods=["POST"])
@admin_required
def toggle_ad_budget(user_id):
    budget = UserAdBudget.query.filter_by(user_id=user_id).first_or_404()
    budget.is_active = not budget.is_active
    budget.set_by_admin_id = current_user.id
    db.session.commit()
    flash(f"{'تم تفعيل' if budget.is_active else 'تم تعطيل'} ميزانية المستخدم.", "success")
    return redirect(url_for("admin.ad_budgets"))


# ── 3. Campaign Review & Approval ──

@admin_bp.route("/ad-review")
@admin_required
def ad_review():
    status_filter = request.args.get("status", "pending_approval")
    q = request.args.get("q", "").strip()
    query = AdCampaign.query
    if status_filter:
        query = query.filter(AdCampaign.status == status_filter)
    if q:
        query = query.filter(AdCampaign.name.ilike(f"%{q}%"))
    campaigns = query.order_by(AdCampaign.created_at.desc()).all()
    return render_template("admin/ad_review.html",
        campaigns=campaigns, status_filter=status_filter, q=q)


@admin_bp.route("/ad-review/<int:ad_campaign_id>")
@admin_required
def ad_review_detail(ad_campaign_id):
    ad_camp = AdCampaign.query.get_or_404(ad_campaign_id)
    return render_template("admin/ad_review_detail.html", ad_camp=ad_camp)


@admin_bp.route("/ad-review/<int:ad_campaign_id>/approve", methods=["POST"])
@admin_required
def approve_ad_campaign(ad_campaign_id):
    from datetime import datetime, timedelta
    ad_camp = AdCampaign.query.get_or_404(ad_campaign_id)
    admin_notes = request.form.get("admin_notes", "").strip()

    # Validate budget
    wallet = AdBudgetWallet.query.first()
    if wallet and wallet.remaining < ad_camp.budget_amount:
        flash("الميزانية الكلية غير كافية.", "error")
        return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id))

    user_budget = UserAdBudget.query.filter_by(user_id=ad_camp.user_id).first()
    if user_budget and user_budget.remaining < ad_camp.budget_amount:
        flash("ميزانية المستخدم غير كافية.", "error")
        return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id))

    ad_camp.status = "approved"
    ad_camp.admin_notes = admin_notes
    ad_camp.reviewed_by = current_user.id
    ad_camp.reviewed_at = datetime.utcnow()
    if not ad_camp.start_date:
        ad_camp.start_date = datetime.utcnow()
    if not ad_camp.end_date:
        ad_camp.end_date = ad_camp.start_date + timedelta(days=ad_camp.duration_days or 7)

    log = AdAuditLog(
        admin_id=current_user.id, user_id=ad_camp.user_id,
        ad_campaign_id=ad_camp.id, action="approved",
        details_json={"admin_notes": admin_notes},
    )
    db.session.add(log)

    # Create notification
    _notify_user(ad_camp.user_id, f"تم اعتماد حملتك الإعلانية: {ad_camp.name}")

    # Auto-publish to platforms
    _publish_ad_campaign(ad_camp)

    db.session.commit()
    flash("تم اعتماد الحملة وإرسالها للنشر.", "success")
    return redirect(url_for("admin.ad_review"))


@admin_bp.route("/ad-review/<int:ad_campaign_id>/reject", methods=["POST"])
@admin_required
def reject_ad_campaign(ad_campaign_id):
    from datetime import datetime
    ad_camp = AdCampaign.query.get_or_404(ad_campaign_id)
    reason = request.form.get("rejection_reason", "").strip()

    ad_camp.status = "rejected"
    ad_camp.rejection_reason = reason
    ad_camp.reviewed_by = current_user.id
    ad_camp.reviewed_at = datetime.utcnow()

    log = AdAuditLog(
        admin_id=current_user.id, user_id=ad_camp.user_id,
        ad_campaign_id=ad_camp.id, action="rejected",
        details_json={"rejection_reason": reason},
    )
    db.session.add(log)
    _notify_user(ad_camp.user_id, f"تم رفض حملتك الإعلانية: {ad_camp.name}. السبب: {reason}")
    db.session.commit()
    flash("تم رفض الحملة.", "success")
    return redirect(url_for("admin.ad_review"))


@admin_bp.route("/ad-review/<int:ad_campaign_id>/modify", methods=["POST"])
@admin_required
def modify_ad_campaign(ad_campaign_id):
    import json as _json
    ad_camp = AdCampaign.query.get_or_404(ad_campaign_id)

    # Admin can modify targeting, budget, duration before approving
    budget = request.form.get("budget_amount", type=float)
    daily_budget = request.form.get("daily_budget", type=float)
    duration = request.form.get("duration_days", type=int)
    admin_notes = request.form.get("admin_notes", "").strip()
    targeting_str = request.form.get("targeting_json", "").strip()

    changes = {}
    if budget is not None and budget != ad_camp.budget_amount:
        changes["budget_amount"] = {"old": ad_camp.budget_amount, "new": budget}
        ad_camp.budget_amount = budget
    if daily_budget is not None and daily_budget != ad_camp.daily_budget:
        changes["daily_budget"] = {"old": ad_camp.daily_budget, "new": daily_budget}
        ad_camp.daily_budget = daily_budget
    if duration is not None and duration != ad_camp.duration_days:
        changes["duration_days"] = {"old": ad_camp.duration_days, "new": duration}
        ad_camp.duration_days = duration
    if targeting_str:
        try:
            new_targeting = _json.loads(targeting_str)
            ad_camp.targeting_json = new_targeting
            changes["targeting"] = "modified"
        except _json.JSONDecodeError:
            flash("JSON الاستهداف غير صالح.", "error")
            return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id))
    if admin_notes:
        ad_camp.admin_notes = admin_notes

    log = AdAuditLog(
        admin_id=current_user.id, user_id=ad_camp.user_id,
        ad_campaign_id=ad_camp.id, action="modified",
        details_json=changes,
    )
    db.session.add(log)
    db.session.commit()
    flash("تم تعديل الحملة.", "success")
    return redirect(url_for("admin.ad_review_detail", ad_campaign_id=ad_campaign_id))


@admin_bp.route("/ad-review/<int:ad_campaign_id>/pause", methods=["POST"])
@admin_required
def pause_ad_campaign(ad_campaign_id):
    from datetime import datetime
    ad_camp = AdCampaign.query.get_or_404(ad_campaign_id)
    ad_camp.status = "paused"
    log = AdAuditLog(
        admin_id=current_user.id, user_id=ad_camp.user_id,
        ad_campaign_id=ad_camp.id, action="paused",
    )
    db.session.add(log)
    _notify_user(ad_camp.user_id, f"تم إيقاف حملتك الإعلانية مؤقتاً: {ad_camp.name}")
    db.session.commit()
    flash("تم إيقاف الحملة.", "success")
    return redirect(url_for("admin.ad_review"))


@admin_bp.route("/ad-review/<int:ad_campaign_id>/resume", methods=["POST"])
@admin_required
def resume_ad_campaign(ad_campaign_id):
    ad_camp = AdCampaign.query.get_or_404(ad_campaign_id)
    ad_camp.status = "active"
    log = AdAuditLog(
        admin_id=current_user.id, user_id=ad_camp.user_id,
        ad_campaign_id=ad_camp.id, action="resumed",
    )
    db.session.add(log)
    db.session.commit()
    flash("تم استئناف الحملة.", "success")
    return redirect(url_for("admin.ad_review"))


# ── 4. Admin Ad Analytics ──

@admin_bp.route("/ad-analytics")
@admin_required
def ad_analytics():
    from datetime import datetime, timedelta
    from sqlalchemy import func

    # Filters
    user_id = request.args.get("user_id", type=int)
    campaign_id = request.args.get("campaign_id", type=int)
    platform = request.args.get("platform", "").strip()
    status = request.args.get("status", "").strip()
    date_from = request.args.get("date_from", "").strip()
    date_to = request.args.get("date_to", "").strip()
    q = request.args.get("q", "").strip()
    spend_min = request.args.get("spend_min", type=float)
    spend_max = request.args.get("spend_max", type=float)

    # Base query for campaigns
    camp_query = AdCampaign.query
    if user_id:
        camp_query = camp_query.filter(AdCampaign.user_id == user_id)
    if campaign_id:
        camp_query = camp_query.filter(AdCampaign.id == campaign_id)
    if status:
        camp_query = camp_query.filter(AdCampaign.status == status)
    if q:
        camp_query = camp_query.filter(AdCampaign.name.ilike(f"%{q}%"))
    campaigns = camp_query.order_by(AdCampaign.created_at.desc()).all()

    # Metrics query
    metrics_query = AdCampaignMetrics.query
    campaign_ids = [c.id for c in campaigns]
    if campaign_ids:
        metrics_query = metrics_query.filter(AdCampaignMetrics.ad_campaign_id.in_(campaign_ids))
    else:
        metrics_query = metrics_query.filter(False)
    if platform:
        metrics_query = metrics_query.filter(AdCampaignMetrics.platform == platform)
    if date_from:
        metrics_query = metrics_query.filter(AdCampaignMetrics.date >= date_from)
    if date_to:
        metrics_query = metrics_query.filter(AdCampaignMetrics.date <= date_to)

    all_metrics = metrics_query.all()

    # Aggregate stats
    total_spend = sum(m.spend for m in all_metrics)
    total_views = sum(m.views for m in all_metrics)
    total_clicks = sum(m.clicks for m in all_metrics)
    total_impressions = sum(m.impressions for m in all_metrics)
    avg_ctr = round((total_clicks / total_impressions * 100), 2) if total_impressions > 0 else 0
    avg_cpv = round(total_spend / total_views, 4) if total_views > 0 else 0
    avg_cpc = round(total_spend / total_clicks, 4) if total_clicks > 0 else 0

    # Filter by spend range (post-aggregation per campaign)
    if spend_min is not None or spend_max is not None:
        filtered_campaigns = []
        for c in campaigns:
            c_spend = sum(m.spend for m in all_metrics if m.ad_campaign_id == c.id)
            if spend_min is not None and c_spend < spend_min:
                continue
            if spend_max is not None and c_spend > spend_max:
                continue
            filtered_campaigns.append(c)
        campaigns = filtered_campaigns

    # Daily spend data for chart
    daily_data = {}
    for m in all_metrics:
        d = str(m.date)
        if d not in daily_data:
            daily_data[d] = {"spend": 0, "views": 0, "clicks": 0}
        daily_data[d]["spend"] += m.spend
        daily_data[d]["views"] += m.views
        daily_data[d]["clicks"] += m.clicks
    daily_labels = sorted(daily_data.keys())
    daily_spend = [round(daily_data[d]["spend"], 2) for d in daily_labels]
    daily_views = [daily_data[d]["views"] for d in daily_labels]
    daily_clicks = [daily_data[d]["clicks"] for d in daily_labels]

    # Platform breakdown
    platform_spend = {}
    for m in all_metrics:
        platform_spend[m.platform] = platform_spend.get(m.platform, 0) + m.spend

    # User breakdown
    user_spend = {}
    for c in campaigns:
        c_spend = sum(m.spend for m in all_metrics if m.ad_campaign_id == c.id)
        uname = c.user.name if c.user else f"User #{c.user_id}"
        user_spend[uname] = user_spend.get(uname, 0) + c_spend

    # All users for filter dropdown
    all_users = User.query.order_by(User.name).all()
    all_ad_campaigns = AdCampaign.query.order_by(AdCampaign.name).all()
    wallet = AdBudgetWallet.query.first()

    import json as _json
    return render_template("admin/ad_analytics.html",
        campaigns=campaigns, all_metrics=all_metrics,
        total_spend=total_spend, total_views=total_views,
        total_clicks=total_clicks, total_impressions=total_impressions,
        avg_ctr=avg_ctr, avg_cpv=avg_cpv, avg_cpc=avg_cpc,
        daily_labels=_json.dumps(daily_labels),
        daily_spend=_json.dumps(daily_spend),
        daily_views=_json.dumps(daily_views),
        daily_clicks=_json.dumps(daily_clicks),
        platform_spend=_json.dumps(platform_spend),
        user_spend=_json.dumps(user_spend),
        all_users=all_users, all_ad_campaigns=all_ad_campaigns,
        wallet=wallet,
        # Current filters
        f_user_id=user_id, f_campaign_id=campaign_id,
        f_platform=platform, f_status=status,
        f_date_from=date_from, f_date_to=date_to,
        f_q=q, f_spend_min=spend_min, f_spend_max=spend_max,
        active_campaigns=sum(1 for c in campaigns if c.status == "active"),
        unique_advertisers=len(set(c.user_id for c in campaigns)),
    )


@admin_bp.route("/ad-analytics/export-csv")
@admin_required
def export_ad_csv():
    """Export all ad campaign metrics as CSV."""
    import csv
    import io
    from flask import Response

    metrics = AdCampaignMetrics.query.order_by(AdCampaignMetrics.date.desc()).all()
    output = io.StringIO()
    writer = csv.writer(output)
    writer.writerow([
        "Campaign ID", "Campaign Name", "User", "Platform", "Date",
        "Impressions", "Views", "Clicks", "CTR", "Spend",
        "CPV", "CPC", "Likes", "Comments", "Shares", "Reach", "Frequency"
    ])
    for m in metrics:
        camp = AdCampaign.query.get(m.ad_campaign_id)
        user_name = camp.user.name if camp and camp.user else ""
        camp_name = camp.name if camp else ""
        writer.writerow([
            m.ad_campaign_id, camp_name, user_name, m.platform, m.date,
            m.impressions, m.views, m.clicks, m.ctr, m.spend,
            m.cost_per_view, m.cost_per_click, m.likes, m.comments,
            m.shares, m.reach, m.frequency
        ])

    output.seek(0)
    return Response(
        output.getvalue(),
        mimetype="text/csv",
        headers={"Content-Disposition": "attachment; filename=ad_campaign_metrics.csv"}
    )


# ── Helper Functions ──

def _notify_user(user_id, message):
    """Create a notification for a user."""
    try:
        from app.models.features import Notification
        notif = Notification(user_id=user_id, title="إشعار حملة إعلانية", message=message, category="ads")
        db.session.add(notif)
    except Exception:
        pass


def _publish_ad_campaign(ad_camp):
    """Publish approved ad campaign to all selected platforms."""
    from app.ads import get_ad_platform
    from app.ai.diamond import run_sync

    platform_ids = {}
    for platform_name in (ad_camp.platforms_list or []):
        account = AdminAdAccount.query.filter_by(platform=platform_name, is_active=True).first()
        if not account:
            platform_ids[platform_name] = {"error": "No active admin account"}
            continue
        try:
            ad_platform = get_ad_platform(platform_name)
            result = run_sync(ad_platform.create_campaign(ad_camp, account))
            platform_ids[platform_name] = result
            if result.get("status") == "active":
                ad_camp.status = "active"
        except Exception as e:
            platform_ids[platform_name] = {"error": str(e)}

    ad_camp.platform_ids_json = platform_ids

    # Update wallet and user budget
    wallet = AdBudgetWallet.query.first()
    if wallet:
        wallet.total_spent += ad_camp.budget_amount
    user_budget = UserAdBudget.query.filter_by(user_id=ad_camp.user_id).first()
    if user_budget:
        user_budget.total_spent += ad_camp.budget_amount


# ══════════════════════════════════════════════════════════════
#  Sponsor Social Accounts — Admin Routes
# ══════════════════════════════════════════════════════════════

@admin_bp.route("/sponsor-accounts")
@admin_required
def sponsor_accounts():
    accounts = SponsorSocialAccount.query.order_by(SponsorSocialAccount.platform).all()
    return render_template("admin/sponsor_accounts.html", accounts=accounts)


@admin_bp.route("/sponsor-accounts/save", methods=["POST"])
@admin_required
def save_sponsor_account():
    platform = request.form.get("platform", "").strip()
    account_name = request.form.get("account_name", "").strip()
    platform_username = request.form.get("platform_username", "").strip()
    access_token = request.form.get("access_token", "").strip()
    refresh_token = request.form.get("refresh_token", "").strip()
    platform_user_id = request.form.get("platform_user_id", "").strip()
    notes = request.form.get("notes", "").strip()
    is_active = request.form.get("is_active") == "1"

    if not platform:
        flash("يرجى اختيار المنصة.", "error")
        return redirect(url_for("admin.sponsor_accounts"))

    # Check if account for this platform already exists
    acc = SponsorSocialAccount.query.filter_by(platform=platform).first()
    if acc:
        if account_name:
            acc.account_name = account_name
        if platform_username:
            acc.platform_username = platform_username
        if access_token:
            acc.access_token = access_token
        if refresh_token:
            acc.refresh_token = refresh_token
        if platform_user_id:
            acc.platform_user_id = platform_user_id
        acc.notes = notes
        acc.is_active = is_active
        acc.updated_by = current_user.id
        flash(f"تم تحديث حساب الراعي لـ {platform}.", "success")
    else:
        acc = SponsorSocialAccount(
            platform=platform,
            account_name=account_name or f"حساب {platform}",
            platform_username=platform_username,
            access_token=access_token,
            refresh_token=refresh_token,
            platform_user_id=platform_user_id,
            notes=notes,
            is_active=is_active,
            updated_by=current_user.id,
        )
        db.session.add(acc)
        flash(f"تم إضافة حساب الراعي لـ {platform}.", "success")

    db.session.commit()
    return redirect(url_for("admin.sponsor_accounts"))


@admin_bp.route("/sponsor-accounts/toggle/<int:account_id>", methods=["POST"])
@admin_required
def toggle_sponsor_account(account_id):
    acc = SponsorSocialAccount.query.get_or_404(account_id)
    acc.is_active = not acc.is_active
    acc.updated_by = current_user.id
    db.session.commit()
    flash(f"تم {'تفعيل' if acc.is_active else 'تعطيل'} حساب {acc.platform}.", "success")
    return redirect(url_for("admin.sponsor_accounts"))


@admin_bp.route("/sponsor-accounts/delete/<int:account_id>", methods=["POST"])
@admin_required
def delete_sponsor_account(account_id):
    acc = SponsorSocialAccount.query.get_or_404(account_id)
    name = acc.platform
    db.session.delete(acc)
    db.session.commit()
    flash(f"تم حذف حساب الراعي لـ {name}.", "success")
    return redirect(url_for("admin.sponsor_accounts"))


# ══════════════════════════════════════════════════════════════
# NotebookLM Settings
# ══════════════════════════════════════════════════════════════

@admin_bp.route("/notebooklm")
@admin_required
def notebooklm_settings():
    from flask import current_app
    from app.ai.notebooklm_service import check_session_valid
    mode = current_app.config.get("NOTEBOOKLM_MODE", "admin_shared")
    enabled = current_app.config.get("NOTEBOOKLM_ENABLED", False)
    admin_connected = check_session_valid("admin")
    return render_template("admin/notebooklm.html",
        mode=mode, enabled=enabled, admin_connected=admin_connected)


@admin_bp.route("/notebooklm/set-mode", methods=["POST"])
@admin_required
def set_notebooklm_mode():
    mode = request.form.get("mode", "admin_shared").strip()
    if mode not in ("admin_shared", "per_user"):
        flash("وضع غير صالح.", "error")
        return redirect(url_for("admin.notebooklm_settings"))

    from flask import current_app
    current_app.config["NOTEBOOKLM_MODE"] = mode

    import os
    env_path = os.path.join(current_app.root_path, "..", ".env")
    env_path = os.path.abspath(env_path)
    _update_env_var(env_path, "NOTEBOOKLM_MODE", mode)

    flash(f"تم تغيير وضع NotebookLM إلى: {'حساب مشترك (الأدمن)' if mode == 'admin_shared' else 'حساب منفصل لكل مستخدم'}.", "success")
    return redirect(url_for("admin.notebooklm_settings"))


@admin_bp.route("/notebooklm/toggle", methods=["POST"])
@admin_required
def toggle_notebooklm():
    from flask import current_app
    current_enabled = current_app.config.get("NOTEBOOKLM_ENABLED", False)
    new_val = not current_enabled
    current_app.config["NOTEBOOKLM_ENABLED"] = new_val

    import os
    env_path = os.path.join(current_app.root_path, "..", ".env")
    env_path = os.path.abspath(env_path)
    _update_env_var(env_path, "NOTEBOOKLM_ENABLED", "true" if new_val else "false")

    flash(f"تم {'تفعيل' if new_val else 'تعطيل'} NotebookLM.", "success")
    return redirect(url_for("admin.notebooklm_settings"))


@admin_bp.route("/notebooklm/connect-admin", methods=["POST"])
@admin_required
def connect_admin_notebooklm():
    """Connect the shared admin Google account for NotebookLM."""
    try:
        from app.ai.notebooklm_service import start_google_login_sync
        storage_path = start_google_login_sync("admin")
        flash("تم ربط حساب Google الخاص بالأدمن بنجاح.", "success")
    except Exception as e:
        flash(f"فشل الربط: {e}", "error")
    return redirect(url_for("admin.notebooklm_settings"))


def _update_env_var(env_path, key, value):
    """Update or add a variable in the .env file."""
    import os
    lines = []
    found = False
    if os.path.exists(env_path):
        with open(env_path, "r", encoding="utf-8") as f:
            lines = f.readlines()
    new_lines = []
    for line in lines:
        if line.strip().startswith(f"{key}="):
            new_lines.append(f"{key}={value}\n")
            found = True
        else:
            new_lines.append(line)
    if not found:
        new_lines.append(f"{key}={value}\n")
    with open(env_path, "w", encoding="utf-8") as f:
        f.writelines(new_lines)