from __future__ import annotations

from typing import Any, Dict, Optional
from uuid import uuid4

from sqlalchemy.orm import Session

from app.database import get_db
from app.models.manager_clone import (
    ManagerBlueprint,
    ManagerClone,
    ManagerCloneAction,
    ManagerCloneVersion,
    ManagerKnowledge,
)


def _get_session() -> Session:
    db_gen = get_db()
    return next(db_gen)


def save_manager_clone(clone_id: str, company_id: str, profile: Dict[str, Any]) -> ManagerClone:
    db = _get_session()
    try:
        clone = ManagerClone(clone_id=clone_id, company_id=company_id, profile=profile)
        db.add(clone)
        db.commit()
        db.refresh(clone)
        return clone
    finally:
        db.close()


def get_manager_clone(clone_id: str) -> Optional[ManagerClone]:
    db = _get_session()
    try:
        return db.query(ManagerClone).filter(ManagerClone.clone_id == clone_id).first()
    finally:
        db.close()


def update_manager_clone(
    clone_id: str, *, profile: Dict[str, Any]
) -> Optional[ManagerClone]:
    db = _get_session()
    try:
        clone = db.query(ManagerClone).filter(ManagerClone.clone_id == clone_id).first()
        if clone is None:
            return None
        clone.profile = profile
        db.commit()
        db.refresh(clone)
        return clone
    finally:
        db.close()


def delete_manager_clone(clone_id: str) -> bool:
    """Hard-delete clone and cascaded children (versions/knowledge/blueprints/actions)."""
    db = _get_session()
    try:
        clone = db.query(ManagerClone).filter(ManagerClone.clone_id == clone_id).first()
        if clone is None:
            return False
        # Explicitly remove actions (no ORM relationship cascade configured).
        db.query(ManagerCloneAction).filter(ManagerCloneAction.clone_id == clone_id).delete()
        db.delete(clone)
        db.commit()
        return True
    finally:
        db.close()


def latest_clone_id() -> Optional[str]:
    """Most recently created manager clone (Swagger Try-it-out convenience)."""
    db = _get_session()
    try:
        row = (
            db.query(ManagerClone)
            .order_by(ManagerClone.created_at.desc(), ManagerClone.id.desc())
            .first()
        )
        return str(row.clone_id) if row else None
    finally:
        db.close()


def ensure_manager_clone(
    clone_id: str,
    *,
    company_id: str = "unknown",
    profile: Optional[Dict[str, Any]] = None,
) -> ManagerClone:
    """Return existing clone or create a stub so FK inserts succeed."""
    existing = get_manager_clone(clone_id)
    if existing is not None:
        return existing
    return save_manager_clone(
        clone_id=clone_id,
        company_id=company_id,
        profile=profile
        or {"notes": "auto-created for knowledge/version write", "style_summary": None},
    )


def save_version(
    clone_id: str, created_by: str, snapshot: Dict[str, Any]
) -> ManagerCloneVersion:
    ensure_manager_clone(clone_id)
    db = _get_session()
    try:
        version = ManagerCloneVersion(
            clone_id=clone_id,
            created_by=created_by,
            configuration_snapshot=snapshot,
        )
        db.add(version)
        db.commit()
        db.refresh(version)
        return version
    finally:
        db.close()


def list_versions(clone_id: str) -> list[ManagerCloneVersion]:
    db = _get_session()
    try:
        return (
            db.query(ManagerCloneVersion)
            .filter(ManagerCloneVersion.clone_id == clone_id)
            .order_by(
                ManagerCloneVersion.created_at.desc(),
                ManagerCloneVersion.id.desc(),
            )
            .all()
        )
    finally:
        db.close()


def get_latest_published_version(clone_id: str) -> Optional[ManagerCloneVersion]:
    db = _get_session()
    try:
        return (
            db.query(ManagerCloneVersion)
            .filter(
                ManagerCloneVersion.clone_id == clone_id,
                ManagerCloneVersion.status == "published",
            )
            .order_by(ManagerCloneVersion.published_at.desc())
            .first()
        )
    finally:
        db.close()


def save_knowledge(
    clone_id: str, file_name: str, file_path: str, extracted_text: Any
) -> ManagerKnowledge:
    ensure_manager_clone(clone_id)
    db = _get_session()
    try:
        payload: Any = extracted_text
        if isinstance(extracted_text, str):
            payload = {"text": extracted_text}
        knowledge = ManagerKnowledge(
            clone_id=clone_id,
            file_name=file_name,
            file_path=file_path,
            extracted_text=payload,
        )
        db.add(knowledge)
        db.commit()
        db.refresh(knowledge)
        return knowledge
    finally:
        db.close()


def get_knowledge(clone_id: str) -> list[ManagerKnowledge]:
    db = _get_session()
    try:
        return (
            db.query(ManagerKnowledge).filter(ManagerKnowledge.clone_id == clone_id).all()
        )
    finally:
        db.close()


def save_blueprint(
    clone_id: str, version_id: str, blueprint: Dict[str, Any]
) -> ManagerBlueprint:
    ensure_manager_clone(clone_id)
    db = _get_session()
    try:
        bp = ManagerBlueprint(
            clone_id=clone_id, version_id=version_id, blueprint=blueprint
        )
        db.add(bp)
        db.commit()
        db.refresh(bp)
        return bp
    finally:
        db.close()


def get_blueprint(clone_id: str, version_id: str) -> Optional[ManagerBlueprint]:
    db = _get_session()
    try:
        return (
            db.query(ManagerBlueprint)
            .filter(
                ManagerBlueprint.clone_id == clone_id,
                ManagerBlueprint.version_id == version_id,
            )
            .first()
        )
    finally:
        db.close()


def save_action(
    *,
    clone_id: str,
    module: str,
    action: str,
    status: str,
    result: Dict[str, Any] | None = None,
    error: str | None = None,
    action_id: str | None = None,
) -> ManagerCloneAction:
    ensure_manager_clone(clone_id)
    db = _get_session()
    try:
        row = ManagerCloneAction(
            action_id=action_id or str(uuid4()),
            clone_id=clone_id,
            module=module,
            action=action,
            status=status,
            result=result or {},
            error=error,
        )
        db.add(row)
        db.commit()
        db.refresh(row)
        return row
    finally:
        db.close()


def get_action(clone_id: str, action_id: str) -> Optional[ManagerCloneAction]:
    db = _get_session()
    try:
        return (
            db.query(ManagerCloneAction)
            .filter(
                ManagerCloneAction.clone_id == clone_id,
                ManagerCloneAction.action_id == action_id,
            )
            .first()
        )
    finally:
        db.close()
