from datetime import datetime
import uuid
from app.extensions import db


class BackgroundTask(db.Model):
    __tablename__ = "background_tasks"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    task_type = db.Column(db.String(100), nullable=False)
    task_id = db.Column(db.String(255), unique=True, nullable=False)
    status = db.Column(db.String(50), default="pending")
    result_json = db.Column(db.JSON, nullable=True)
    error_message = db.Column(db.Text, nullable=True)
    progress = db.Column(db.Integer, default=0)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    completed_at = db.Column(db.DateTime, nullable=True)

    user = db.relationship("User", backref="tasks")


class WebhookEndpoint(db.Model):
    __tablename__ = "webhook_endpoints"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    url = db.Column(db.String(1000), nullable=False)
    events = db.Column(db.JSON, default=list)
    secret = db.Column(db.String(255), nullable=True)
    is_active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="webhooks")


class Workspace(db.Model):
    __tablename__ = "workspaces"

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(255), nullable=False)
    owner_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    invite_code = db.Column(db.String(32), unique=True, default=lambda: uuid.uuid4().hex[:12])
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    owner = db.relationship("User", backref="owned_workspaces")
    members = db.relationship("WorkspaceMember", backref="workspace", cascade="all, delete-orphan")


class WorkspaceMember(db.Model):
    __tablename__ = "workspace_members"

    id = db.Column(db.Integer, primary_key=True)
    workspace_id = db.Column(db.Integer, db.ForeignKey("workspaces.id"), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    role = db.Column(db.String(50), default="member")
    joined_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="workspace_memberships")

    __table_args__ = (db.UniqueConstraint("workspace_id", "user_id"),)


class ReportTemplate(db.Model):
    __tablename__ = "report_templates"

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(255), nullable=False)
    name_ar = db.Column(db.String(255), nullable=False)
    sector = db.Column(db.String(100), nullable=False)
    description = db.Column(db.Text, nullable=True)
    description_ar = db.Column(db.Text, nullable=True)
    default_description = db.Column(db.Text, nullable=False)
    default_description_ar = db.Column(db.Text, nullable=False)
    icon = db.Column(db.String(10), default="📋")
    is_active = db.Column(db.Boolean, default=True)
    usage_count = db.Column(db.Integer, default=0)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)


class AuditLog(db.Model):
    __tablename__ = "audit_logs"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
    action = db.Column(db.String(255), nullable=False)
    resource_type = db.Column(db.String(100), nullable=True)
    resource_id = db.Column(db.Integer, nullable=True)
    details = db.Column(db.JSON, nullable=True)
    ip_address = db.Column(db.String(45), nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="audit_logs")


class Referral(db.Model):
    __tablename__ = "referrals"

    id = db.Column(db.Integer, primary_key=True)
    referrer_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    referred_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)
    code = db.Column(db.String(20), unique=True, nullable=False)
    status = db.Column(db.String(50), default="pending")
    reward_applied = db.Column(db.Boolean, default=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    converted_at = db.Column(db.DateTime, nullable=True)

    referrer = db.relationship("User", foreign_keys=[referrer_id], backref="referrals_sent")
    referred = db.relationship("User", foreign_keys=[referred_id], backref="referral_used")


class ChatMessage(db.Model):
    __tablename__ = "chat_messages"

    id = db.Column(db.Integer, primary_key=True)
    session_id = db.Column(db.String(64), nullable=False, index=True)
    role = db.Column(db.String(20), nullable=False)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)


class CompetitorMonitor(db.Model):
    __tablename__ = "competitor_monitors"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    competitor_url = db.Column(db.String(1000), nullable=False)
    last_snapshot = db.Column(db.JSON, nullable=True)
    last_checked = db.Column(db.DateTime, nullable=True)
    changes_detected = db.Column(db.Integer, default=0)
    is_active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="competitor_monitors")


class InvestorContact(db.Model):
    __tablename__ = "investor_contacts"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=True)
    name = db.Column(db.String(255), nullable=False)
    company = db.Column(db.String(255), nullable=True)
    email = db.Column(db.String(255), nullable=True)
    phone = db.Column(db.String(50), nullable=True)
    stage = db.Column(db.String(50), default="identified")
    notes = db.Column(db.Text, nullable=True)
    last_contact = db.Column(db.DateTime, nullable=True)
    next_followup = db.Column(db.DateTime, nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="investor_contacts")


class MarketplaceListing(db.Model):
    __tablename__ = "marketplace_listings"

    GOAL_CHOICES = ["sell", "find_investor", "find_partner", "license", "free"]

    id = db.Column(db.Integer, primary_key=True)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    listing_goal = db.Column(db.String(30), default="sell")  # sell, find_investor, find_partner, license, free
    title = db.Column(db.String(500), nullable=True)
    sector = db.Column(db.String(100), nullable=True)
    price = db.Column(db.Float, default=0)
    currency = db.Column(db.String(10), default="USD")
    description = db.Column(db.Text, nullable=True)
    preview_text = db.Column(db.Text, nullable=True)
    investment_needed = db.Column(db.Float, nullable=True)
    equity_offered = db.Column(db.Float, nullable=True)  # percentage
    partner_role = db.Column(db.String(500), nullable=True)
    license_terms = db.Column(db.Text, nullable=True)
    contact_email = db.Column(db.String(255), nullable=True)
    cover_image = db.Column(db.String(500), nullable=True)
    approval_status = db.Column(db.String(20), default="pending")  # pending, approved, rejected
    admin_notes = db.Column(db.Text, nullable=True)
    featured = db.Column(db.Boolean, default=False)
    is_active = db.Column(db.Boolean, default=False)
    views = db.Column(db.Integer, default=0)
    purchases = db.Column(db.Integer, default=0)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    report = db.relationship("Report", backref="listing")
    user = db.relationship("User", backref="marketplace_listings")

    @property
    def avg_rating(self):
        reviews = MarketplaceReview.query.filter_by(listing_id=self.id).all()
        if not reviews:
            return 0
        return round(sum(r.rating for r in reviews) / len(reviews), 1)

    @property
    def review_count(self):
        return MarketplaceReview.query.filter_by(listing_id=self.id).count()

    @property
    def goal_label(self):
        labels = {
            "sell": "للبيع",
            "find_investor": "بحث عن مستثمر",
            "find_partner": "بحث عن شريك",
            "license": "ترخيص",
            "free": "مجاني",
        }
        return labels.get(self.listing_goal, self.listing_goal)

    @property
    def goal_color(self):
        colors = {
            "sell": "gold",
            "find_investor": "emerald",
            "find_partner": "blue",
            "license": "purple",
            "free": "slate",
        }
        return colors.get(self.listing_goal, "slate")


class MarketplacePurchase(db.Model):
    __tablename__ = "marketplace_purchases"

    id = db.Column(db.Integer, primary_key=True)
    listing_id = db.Column(db.Integer, db.ForeignKey("marketplace_listings.id"), nullable=False)
    buyer_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    amount = db.Column(db.Float, nullable=False)
    currency = db.Column(db.String(10), default="USD")
    stripe_session_id = db.Column(db.String(255), nullable=True)
    stripe_payment_intent = db.Column(db.String(255), nullable=True)
    status = db.Column(db.String(20), default="pending")  # pending, completed, refunded
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    listing = db.relationship("MarketplaceListing", backref="purchases_list")
    buyer = db.relationship("User", backref="marketplace_purchases")


class MarketplaceInquiry(db.Model):
    """Inquiry from interested investor/partner/licensee to listing owner."""
    __tablename__ = "marketplace_inquiries"

    id = db.Column(db.Integer, primary_key=True)
    listing_id = db.Column(db.Integer, db.ForeignKey("marketplace_listings.id"), nullable=False)
    sender_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    inquiry_type = db.Column(db.String(30), nullable=False)  # invest, partner, license, general
    message = db.Column(db.Text, nullable=False)
    contact_info = db.Column(db.String(500), nullable=True)
    status = db.Column(db.String(20), default="new")  # new, read, replied, accepted, rejected
    reply_message = db.Column(db.Text, nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    listing = db.relationship("MarketplaceListing", backref="inquiries")
    sender = db.relationship("User", backref="marketplace_inquiries_sent")


class MarketplaceReview(db.Model):
    """Buyer review/rating for a purchased listing."""
    __tablename__ = "marketplace_reviews"

    id = db.Column(db.Integer, primary_key=True)
    listing_id = db.Column(db.Integer, db.ForeignKey("marketplace_listings.id"), nullable=False)
    purchase_id = db.Column(db.Integer, db.ForeignKey("marketplace_purchases.id"), nullable=False)
    buyer_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    rating = db.Column(db.Integer, nullable=False)  # 1-5
    comment = db.Column(db.Text, nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    listing = db.relationship("MarketplaceListing", backref="reviews")
    purchase = db.relationship("MarketplacePurchase", backref="review")
    buyer = db.relationship("User", backref="marketplace_reviews")

    __table_args__ = (db.UniqueConstraint("purchase_id", name="uq_purchase_review"),)


class WhiteLabelConfig(db.Model):
    __tablename__ = "white_label_configs"

    id = db.Column(db.Integer, primary_key=True)
    org_name = db.Column(db.String(255), nullable=False)
    logo_url = db.Column(db.String(1000), nullable=True)
    primary_color = db.Column(db.String(20), default="#D2AF20")
    domain = db.Column(db.String(255), nullable=True)
    api_key_hash = db.Column(db.String(255), nullable=False)
    is_active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)


class Grant(db.Model):
    __tablename__ = "grants"

    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(255), nullable=False)
    name_ar = db.Column(db.String(255), nullable=True)
    provider = db.Column(db.String(255), nullable=False)
    country = db.Column(db.String(100), default="SA")
    sector = db.Column(db.String(100), nullable=True)
    max_amount = db.Column(db.Float, nullable=True)
    currency = db.Column(db.String(10), default="SAR")
    url = db.Column(db.String(1000), nullable=True)
    description = db.Column(db.Text, nullable=True)
    deadline = db.Column(db.DateTime, nullable=True)
    is_active = db.Column(db.Boolean, default=True)


class CoFounderProfile(db.Model):
    __tablename__ = "cofounder_profiles"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    skills = db.Column(db.JSON, default=list)
    interests = db.Column(db.JSON, default=list)
    experience_years = db.Column(db.Integer, default=0)
    bio = db.Column(db.Text, nullable=True)
    looking_for = db.Column(db.Text, nullable=True)
    city = db.Column(db.String(100), nullable=True)
    is_visible = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="cofounder_profile")


class ReportVersion(db.Model):
    __tablename__ = "report_versions"

    id = db.Column(db.Integer, primary_key=True)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    version_number = db.Column(db.Integer, nullable=False)
    synthesis_snapshot = db.Column(db.JSON, nullable=True)
    html_snapshot = db.Column(db.Text, nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    report = db.relationship("Report", backref="versions")


class Notification(db.Model):
    __tablename__ = "notifications"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    title = db.Column(db.String(255), nullable=False)
    message = db.Column(db.Text, nullable=True)
    category = db.Column(db.String(50), default="info")
    link = db.Column(db.String(500), nullable=True)
    is_read = db.Column(db.Boolean, default=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="notifications")


class SearchIndex(db.Model):
    __tablename__ = "search_index"

    id = db.Column(db.Integer, primary_key=True)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    content_text = db.Column(db.Text, nullable=False)
    embedding_json = db.Column(db.JSON, nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    report = db.relationship("Report", backref="search_entries")


class ActivityLog(db.Model):
    __tablename__ = "activity_logs"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    workspace_id = db.Column(db.Integer, db.ForeignKey("workspaces.id"), nullable=True)
    action = db.Column(db.String(255), nullable=False)
    resource_type = db.Column(db.String(100), nullable=True)
    resource_id = db.Column(db.Integer, nullable=True)
    resource_name = db.Column(db.String(255), nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="activity_logs")


class KanbanCard(db.Model):
    __tablename__ = "kanban_cards"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=True)
    title = db.Column(db.String(255), nullable=False)
    description = db.Column(db.Text, nullable=True)
    stage = db.Column(db.String(50), default="idea")
    position = db.Column(db.Integer, default=0)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="kanban_cards")
    report = db.relationship("Report", backref="kanban_card")


class LegalDocument(db.Model):
    __tablename__ = "legal_documents"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=True)
    doc_type = db.Column(db.String(100), nullable=False)
    title = db.Column(db.String(255), nullable=False)
    content = db.Column(db.Text, nullable=True)
    language = db.Column(db.String(5), default="ar")
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="legal_documents")
    report = db.relationship("Report", backref="legal_docs")


class ProjectMilestone(db.Model):
    """Roadmap milestones auto-generated from feasibility study."""
    __tablename__ = "project_milestones"

    id = db.Column(db.Integer, primary_key=True)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    title = db.Column(db.String(255), nullable=False)
    description = db.Column(db.Text, nullable=True)
    week_number = db.Column(db.Integer, default=1)
    status = db.Column(db.String(50), default="pending")  # pending, in_progress, completed, skipped
    due_date = db.Column(db.DateTime, nullable=True)
    completed_at = db.Column(db.DateTime, nullable=True)
    position = db.Column(db.Integer, default=0)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    report = db.relationship("Report", backref="milestones")
    user = db.relationship("User", backref="milestones")
    tasks = db.relationship("MilestoneTask", backref="milestone", cascade="all, delete-orphan", order_by="MilestoneTask.position")


class MilestoneTask(db.Model):
    """Individual tasks within a milestone."""
    __tablename__ = "milestone_tasks"

    id = db.Column(db.Integer, primary_key=True)
    milestone_id = db.Column(db.Integer, db.ForeignKey("project_milestones.id"), nullable=False)
    title = db.Column(db.String(255), nullable=False)
    is_done = db.Column(db.Boolean, default=False)
    position = db.Column(db.Integer, default=0)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)


class ProjectKPI(db.Model):
    """KPI definitions for a project, auto-generated from feasibility study."""
    __tablename__ = "project_kpis"

    id = db.Column(db.Integer, primary_key=True)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    name = db.Column(db.String(255), nullable=False)
    unit = db.Column(db.String(50), default="")  # SAR, %, عدد, etc.
    target_value = db.Column(db.Float, nullable=True)  # from feasibility study projection
    category = db.Column(db.String(50), default="financial")  # financial, customers, operations, growth
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    report = db.relationship("Report", backref="kpis")
    user = db.relationship("User", backref="kpis")
    entries = db.relationship("KPIEntry", backref="kpi", cascade="all, delete-orphan", order_by="KPIEntry.month.desc()")


class KPIEntry(db.Model):
    """Monthly actual KPI values entered by user."""
    __tablename__ = "kpi_entries"

    id = db.Column(db.Integer, primary_key=True)
    kpi_id = db.Column(db.Integer, db.ForeignKey("project_kpis.id"), nullable=False)
    month = db.Column(db.String(7), nullable=False)  # YYYY-MM
    actual_value = db.Column(db.Float, nullable=False)
    notes = db.Column(db.Text, nullable=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    __table_args__ = (db.UniqueConstraint("kpi_id", "month", name="uq_kpi_month"),)


class AdvisorChat(db.Model):
    """Persistent AI co-founder chat messages per project."""
    __tablename__ = "advisor_chats"

    id = db.Column(db.Integer, primary_key=True)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    role = db.Column(db.String(20), nullable=False)  # user, assistant
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    report = db.relationship("Report", backref="advisor_chats")
    user = db.relationship("User", backref="advisor_chats")


class MarketAlert(db.Model):
    """Alerts generated from market/competitor monitoring."""
    __tablename__ = "market_alerts"

    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=False)
    report_id = db.Column(db.Integer, db.ForeignKey("reports.id"), nullable=False)
    alert_type = db.Column(db.String(50), nullable=False)  # competitor_change, market_trend, price_change, new_competitor
    title = db.Column(db.String(255), nullable=False)
    description = db.Column(db.Text, nullable=True)
    source_url = db.Column(db.String(1000), nullable=True)
    severity = db.Column(db.String(20), default="info")  # info, warning, critical
    is_read = db.Column(db.Boolean, default=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    user = db.relationship("User", backref="market_alerts")
    report = db.relationship("Report", backref="market_alerts")


class AIModelConfig(db.Model):
    __tablename__ = "ai_model_configs"

    id = db.Column(db.Integer, primary_key=True)
    screen_name = db.Column(db.String(100), nullable=False)
    plan_name = db.Column(db.String(50), nullable=False)
    provider = db.Column(db.String(50), nullable=False, default="openai")
    model_name = db.Column(db.String(100), nullable=False, default="gpt-4o-mini")
    api_key_override = db.Column(db.Text, nullable=True)
    max_tokens = db.Column(db.Integer, default=16384)
    temperature = db.Column(db.Float, default=0.7)
    is_active = db.Column(db.Boolean, default=True)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)

    __table_args__ = (db.UniqueConstraint("screen_name", "plan_name", name="uq_screen_plan"),)

    SCREEN_CHOICES = [
        ("feasibility_study", "دراسة الجدوى"),
        ("competitor_analysis", "تحليل المنافسين"),
        ("video_script", "سيناريو الفيديو"),
        ("ai_advisor", "المستشار الذكي"),
        ("pitch_deck", "العرض التقديمي"),
        ("legal_docs", "المستندات القانونية"),
        ("brand_kit", "الهوية البصرية"),
        ("chatbot", "الشات بوت"),
    ]

    PROVIDER_CHOICES = [
        ("openai", "OpenAI"),
        ("anthropic", "Anthropic"),
    ]


class SystemPrompt(db.Model):
    __tablename__ = "system_prompts"

    id = db.Column(db.Integer, primary_key=True)
    service_key = db.Column(db.String(100), unique=True, nullable=False, index=True)
    display_name = db.Column(db.String(200), nullable=False)
    system_prompt = db.Column(db.Text, nullable=False, default="")
    user_prompt_template = db.Column(db.Text, nullable=True)
    is_active = db.Column(db.Boolean, default=True)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    updated_by = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)

    SERVICE_CHOICES = [
        ("market_logic", "تحليل السوق — Market Logic"),
        ("financial", "التحليل المالي — Financial Analysis"),
        ("competitive", "التحليل التنافسي — Competitive Analysis"),
        ("synthesis", "التوليف النهائي — Final Synthesis"),
        ("ai_advisor", "المستشار الذكي — AI Advisor"),
        ("video_script", "سيناريو الفيديو — Video Script"),
        ("pitch_deck", "العرض التقديمي — Pitch Deck"),
        ("legal_docs", "المستندات القانونية — Legal Docs"),
        ("brand_kit", "الهوية البصرية — Brand Kit"),
        ("incubator", "حاضنة الأعمال — Incubator"),
    ]

    @staticmethod
    def get_prompt(service_key):
        """Get active prompt for a service. Returns (system_prompt, user_prompt_template) or (None, None)."""
        p = SystemPrompt.query.filter_by(service_key=service_key, is_active=True).first()
        if p:
            return p.system_prompt, p.user_prompt_template
        return None, None


class VideoProviderConfig(db.Model):
    """Admin-managed API keys and settings for video generation providers."""
    __tablename__ = "video_provider_configs"

    id = db.Column(db.Integer, primary_key=True)
    provider_name = db.Column(db.String(50), unique=True, nullable=False, index=True)
    display_name = db.Column(db.String(100), nullable=False)
    is_active = db.Column(db.Boolean, default=True)
    api_key = db.Column(db.Text, nullable=True)
    api_secret = db.Column(db.Text, nullable=True)
    extra_config = db.Column(db.JSON, nullable=True)
    notes = db.Column(db.Text, nullable=True)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    updated_by = db.Column(db.Integer, db.ForeignKey("users.id"), nullable=True)

    PROVIDER_DEFS = [
        {
            "name": "sora",
            "display": "OpenAI Sora",
            "key_label": "OPENAI_API_KEY",
            "secret_label": None,
            "env_key": "OPENAI_API_KEY",
            "env_secret": None,
            "doc_url": "https://platform.openai.com/api-keys",
            "price_info": "~$2-5/فيديو — 12 ثانية",
            "supported_durations": [4, 8, 12],
        },
        {
            "name": "veo",
            "display": "Google Veo 3",
            "key_label": "GOOGLE_GEMINI_API_KEY",
            "secret_label": None,
            "env_key": "GOOGLE_GEMINI_API_KEY",
            "env_secret": None,
            "doc_url": "https://aistudio.google.com/apikey",
            "price_info": "~$0.50/فيديو — 8 ثانية + صوت",
            "supported_durations": [5, 8],
        },
        {
            "name": "kling",
            "display": "Kling AI",
            "key_label": "Access Key",
            "secret_label": "Secret Key",
            "env_key": "KLING_ACCESS_KEY",
            "env_secret": "KLING_SECRET_KEY",
            "doc_url": "https://klingai.com/global/dev/pricing",
            "price_info": "$0.14-$0.98/فيديو — أفضل سعر ⭐",
            "supported_durations": [5, 10],
        },
        {
            "name": "runway",
            "display": "Runway Gen-4",
            "key_label": "API Key",
            "secret_label": None,
            "env_key": "RUNWAY_API_KEY",
            "env_secret": None,
            "doc_url": "https://dev.runwayml.com/",
            "price_info": "$0.05-$0.10/فيديو — سينمائي",
            "supported_durations": [5, 10],
        },
        {
            "name": "pika",
            "display": "Pika Labs",
            "key_label": "API Key",
            "secret_label": None,
            "env_key": "PIKA_API_KEY",
            "env_secret": None,
            "doc_url": "https://pika.art/",
            "price_info": "~$0.04/فيديو — إبداعي",
            "supported_durations": [3, 4],
        },
        {
            "name": "fal",
            "display": "fal.ai",
            "key_label": "API Key (key_id:key_secret)",
            "secret_label": None,
            "env_key": "FAL_KEY",
            "env_secret": None,
            "doc_url": "https://fal.ai/dashboard/keys",
            "price_info": "~$0.02-$0.10/فيديو — متعدد النماذج",
            "supported_durations": [5, 10],
        },
    ]

    @staticmethod
    def get_provider_config(provider_name):
        """Get active config for a provider. Returns (api_key, api_secret, extra_config) or (None, None, None)."""
        cfg = VideoProviderConfig.query.filter_by(provider_name=provider_name, is_active=True).first()
        if cfg and cfg.api_key:
            return cfg.api_key, cfg.api_secret, cfg.extra_config
        return None, None, None

    @staticmethod
    def get_active_providers():
        """Return list of provider_name strings that are active and have API keys."""
        configs = VideoProviderConfig.query.filter_by(is_active=True).all()
        return [c.provider_name for c in configs if c.api_key]

    @staticmethod
    def get_allowed_durations(provider_name):
        """Return list of durations the admin has enabled for this provider.
        Uses extra_config['allowed_durations'] if set, otherwise falls back to supported_durations from PROVIDER_DEFS."""
        cfg = VideoProviderConfig.query.filter_by(provider_name=provider_name, is_active=True).first()
        if cfg and cfg.extra_config and isinstance(cfg.extra_config, dict):
            admin_durations = cfg.extra_config.get("allowed_durations")
            if admin_durations and isinstance(admin_durations, list):
                return sorted([int(d) for d in admin_durations])
        # Fallback to provider defaults
        for pdef in VideoProviderConfig.PROVIDER_DEFS:
            if pdef["name"] == provider_name:
                return pdef.get("supported_durations", [5, 10])
        return [5, 10]