"""
Knowledge Base Models
FAQ, Articles, and Training Data for AI Chatbots
"""
from datetime import datetime
from sqlalchemy import Column, Integer, String, Text, Boolean, DateTime, ForeignKey, Float, Enum as SQLEnum
from sqlalchemy.orm import relationship
import enum

from app.models.base import Base, TimestampMixin, SoftDeleteMixin


class ArticleStatus(str, enum.Enum):
    """Article status"""
    DRAFT = "draft"
    PUBLISHED = "published"
    ARCHIVED = "archived"


class DataSourceType(str, enum.Enum):
    """Training data source type"""
    FAQ = "faq"
    ARTICLE = "article"
    DOCUMENT = "document"
    WEBSITE = "website"
    CSV = "csv"
    JSON = "json"
    API = "api"


class KnowledgeBaseCategory(Base, TimestampMixin, SoftDeleteMixin):
    """
    Knowledge Base Category - Organize FAQs and Articles
    """
    __tablename__ = "kb_categories"

    id = Column(Integer, primary_key=True, index=True)
    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False, index=True)

    # Category Info
    name = Column(String(100), nullable=False)
    slug = Column(String(100), nullable=False)
    description = Column(Text, nullable=True)
    icon = Column(String(50), nullable=True)  # Icon name or emoji
    color = Column(String(20), nullable=True)  # Hex color

    # Hierarchy
    parent_id = Column(Integer, ForeignKey("kb_categories.id"), nullable=True)

    # Display
    display_order = Column(Integer, default=0)
    is_visible = Column(Boolean, default=True)

    # Relationships
    articles = relationship("KnowledgeBaseArticle", back_populates="category")
    faqs = relationship("FAQ", back_populates="category")
    parent = relationship("KnowledgeBaseCategory", remote_side=[id], backref="subcategories")

    def __repr__(self):
        return f"<KBCategory {self.id}: {self.name}>"


class KnowledgeBaseArticle(Base, TimestampMixin, SoftDeleteMixin):
    """
    Knowledge Base Article - Long-form content
    """
    __tablename__ = "kb_articles"

    id = Column(Integer, primary_key=True, index=True)
    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False, index=True)
    category_id = Column(Integer, ForeignKey("kb_categories.id"), nullable=True, index=True)

    # Article Info
    title = Column(String(255), nullable=False)
    slug = Column(String(255), nullable=False, index=True)
    summary = Column(Text, nullable=True)  # Short description
    content = Column(Text, nullable=False)  # Full content (HTML/Markdown)
    content_format = Column(String(20), default="markdown")  # markdown, html, text

    # SEO
    meta_title = Column(String(255), nullable=True)
    meta_description = Column(String(500), nullable=True)
    keywords = Column(String(500), nullable=True)  # Comma-separated

    # Media
    featured_image = Column(String(500), nullable=True)

    # Status
    status = Column(SQLEnum(ArticleStatus), default=ArticleStatus.DRAFT)
    published_at = Column(DateTime, nullable=True)

    # Analytics
    view_count = Column(Integer, default=0)
    helpful_count = Column(Integer, default=0)
    not_helpful_count = Column(Integer, default=0)

    # AI Training
    include_in_training = Column(Boolean, default=True)
    embedding_vector = Column(Text, nullable=True)  # JSON array of floats
    last_trained_at = Column(DateTime, nullable=True)

    # Authorship
    author_id = Column(Integer, ForeignKey("users.id"), nullable=True)

    # Relationships
    category = relationship("KnowledgeBaseCategory", back_populates="articles")

    def __repr__(self):
        return f"<KBArticle {self.id}: {self.title}>"


class FAQ(Base, TimestampMixin, SoftDeleteMixin):
    """
    FAQ - Frequently Asked Questions
    """
    __tablename__ = "faqs"

    id = Column(Integer, primary_key=True, index=True)
    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False, index=True)
    category_id = Column(Integer, ForeignKey("kb_categories.id"), nullable=True, index=True)

    # FAQ Content
    question = Column(Text, nullable=False)
    answer = Column(Text, nullable=False)
    answer_format = Column(String(20), default="text")  # text, markdown, html

    # Variations (for better AI matching)
    question_variations = Column(Text, nullable=True)  # JSON array of variations

    # Display
    display_order = Column(Integer, default=0)
    is_featured = Column(Boolean, default=False)
    is_visible = Column(Boolean, default=True)

    # Status
    status = Column(SQLEnum(ArticleStatus), default=ArticleStatus.PUBLISHED)

    # Analytics
    view_count = Column(Integer, default=0)
    helpful_count = Column(Integer, default=0)
    not_helpful_count = Column(Integer, default=0)
    times_asked = Column(Integer, default=0)  # How often this was matched

    # AI Training
    include_in_training = Column(Boolean, default=True)
    embedding_vector = Column(Text, nullable=True)
    confidence_threshold = Column(Float, default=0.7)  # Min confidence to use this FAQ
    last_trained_at = Column(DateTime, nullable=True)

    # Relationships
    category = relationship("KnowledgeBaseCategory", back_populates="faqs")

    def __repr__(self):
        return f"<FAQ {self.id}: {self.question[:50]}...>"


class TrainingData(Base, TimestampMixin, SoftDeleteMixin):
    """
    Training Data - Custom training data for AI models
    """
    __tablename__ = "training_data"

    id = Column(Integer, primary_key=True, index=True)
    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False, index=True)

    # Source Info
    source_type = Column(SQLEnum(DataSourceType), nullable=False)
    source_name = Column(String(255), nullable=False)  # File name, URL, etc.
    source_url = Column(String(500), nullable=True)  # Original URL if applicable

    # File Info (if file upload)
    file_path = Column(String(500), nullable=True)
    file_size = Column(Integer, nullable=True)
    file_type = Column(String(50), nullable=True)

    # Content
    content = Column(Text, nullable=True)  # Extracted/processed content
    content_hash = Column(String(64), nullable=True)  # For deduplication

    # Processing
    is_processed = Column(Boolean, default=False)
    processed_at = Column(DateTime, nullable=True)
    processing_error = Column(Text, nullable=True)

    # Training Status
    is_trained = Column(Boolean, default=False)
    trained_at = Column(DateTime, nullable=True)
    embedding_count = Column(Integer, default=0)  # Number of embeddings generated

    # Metadata
    metadata_json = Column(Text, nullable=True)  # Additional metadata as JSON

    # Uploaded by
    uploaded_by_id = Column(Integer, ForeignKey("users.id"), nullable=True)

    def __repr__(self):
        return f"<TrainingData {self.id}: {self.source_name}>"


class TrainingJob(Base, TimestampMixin):
    """
    Training Job - Track AI training jobs
    """
    __tablename__ = "training_jobs"

    id = Column(Integer, primary_key=True, index=True)
    client_id = Column(Integer, ForeignKey("clients.id"), nullable=False, index=True)

    # Job Info
    job_type = Column(String(50), nullable=False)  # full, incremental, faq_only
    status = Column(String(20), default="pending")  # pending, running, completed, failed

    # Progress
    total_items = Column(Integer, default=0)
    processed_items = Column(Integer, default=0)
    error_count = Column(Integer, default=0)

    # Timing
    started_at = Column(DateTime, nullable=True)
    completed_at = Column(DateTime, nullable=True)

    # Results
    result_summary = Column(Text, nullable=True)  # JSON summary
    error_log = Column(Text, nullable=True)

    # Triggered by
    triggered_by_id = Column(Integer, ForeignKey("users.id"), nullable=True)

    def __repr__(self):
        return f"<TrainingJob {self.id}: {self.job_type} - {self.status}>"