from __future__ import annotations

import hashlib
from datetime import datetime
from pathlib import PurePosixPath
from typing import Any
from uuid import UUID

from sqlalchemy import func, select
from sqlalchemy.orm import Session

from ..config import Settings
from ..docs_repository import DocsRepository
from ..markdown import parse_frontmatter
from ..pending_changes import PendingChangeError, ProposedChangeRequest
from .db import Database
from .models import (
    AuditLog,
    Blob,
    ChangeItem,
    Changeset,
    DocVersion,
    Document,
    InventoryItem,
    InventoryItemVersion,
    InventoryType,
    utcnow,
)
from .validation import validate_session


def _iso(value: datetime | None) -> str | None:
    if value is None:
        return None
    return value.isoformat().replace("+00:00", "Z")


def _content_hash(raw: str) -> str:
    return hashlib.sha256(raw.encode("utf-8")).hexdigest()


def _serialize(changeset: Changeset, items: list[ChangeItem]) -> dict[str, Any]:
    primary = items[0]
    return {
        "id": str(changeset.id),
        "kind": primary.kind,
        "target": primary.target,
        "summary": changeset.summary,
        "reason": changeset.reason,
        "payload": dict(primary.payload or {}),
        "status": changeset.status,
        "created_at": _iso(changeset.created_at),
        "updated_at": _iso(changeset.applied_at or changeset.created_at),
        "applied_at": _iso(changeset.applied_at),
        "validation": changeset.validation,
        "items": [
            {
                "id": str(item.id),
                "kind": item.kind,
                "target": item.target,
                "status": item.status,
                "payload": dict(item.payload or {}),
            }
            for item in items
        ],
    }


class PostgresPendingChangeRepository:
    def __init__(self, database: Database, settings: Settings, via: str = "api") -> None:
        self.database = database
        self.settings = settings
        self.via = via

    def list(self) -> list[dict[str, Any]]:
        with self.database.session() as session:
            changesets = session.scalars(
                select(Changeset).order_by(Changeset.created_at.desc())
            ).all()
            result: list[dict[str, Any]] = []
            for changeset in changesets:
                items = self._items(session, changeset.id)
                if items:
                    result.append(_serialize(changeset, items))
            return result

    def get(self, change_id: str) -> dict[str, Any]:
        with self.database.session() as session:
            changeset = self._changeset(session, change_id)
            items = self._items(session, changeset.id)
            if not items:
                raise PendingChangeError("Pending change not found")
            return _serialize(changeset, items)

    def create(self, request: ProposedChangeRequest) -> dict[str, Any]:
        with self.database.session() as session:
            with session.begin():
                changeset = Changeset(
                    summary=request.summary,
                    reason=request.reason,
                    status="draft",
                )
                session.add(changeset)
                session.flush()

                item = ChangeItem(
                    changeset_id=changeset.id,
                    kind=request.kind,
                    target=request.target,
                    payload=request.payload,
                    status="draft",
                )
                session.add(item)
                session.flush()

                session.add(
                    AuditLog(
                        actor_kind="agent",
                        actor_name=None,
                        via=self.via,
                        action="propose",
                        entity_type="changeset",
                        entity_id=str(changeset.id),
                        after={
                            "summary": request.summary,
                            "kind": request.kind,
                            "target": request.target,
                        },
                    )
                )
            return _serialize(changeset, [item])

    def apply(self, change_id: str) -> dict[str, Any]:
        with self.database.session() as session:
            with session.begin():
                changeset = self._changeset(session, change_id)
                if changeset.status != "draft":
                    raise PendingChangeError("Only pending changes can be applied")

                items = self._items(session, changeset.id)
                if not items:
                    raise PendingChangeError("Pending change has no items")

                for item in items:
                    if item.kind == "doc":
                        self._apply_doc(session, changeset, item)
                    elif item.kind == "inventory-item":
                        self._apply_inventory_item(session, changeset, item)
                    else:
                        raise PendingChangeError(
                            "Only doc and inventory-item changes can be applied in the current MVP"
                        )
                    item.status = "applied"

                session.flush()
                validation = validate_session(session)
                if validation["status"] != "ok":
                    issues = validation.get("issues", [])
                    details = "\n".join(
                        f"  - {issue['path']} ({issue['code']}): {issue['message']}"
                        for issue in issues[:10]
                    )
                    raise PendingChangeError(
                        "Applied change failed validation and was rolled back. Issues:\n"
                        + details
                    )

                changeset.status = "applied"
                changeset.applied_at = utcnow()
                changeset.validation = validation
                session.add(
                    AuditLog(
                        actor_kind="agent",
                        actor_name=None,
                        via=self.via,
                        action="apply",
                        entity_type="changeset",
                        entity_id=str(changeset.id),
                        after={
                            "summary": changeset.summary,
                            "targets": [item.target for item in items],
                            "validation": validation,
                        },
                    )
                )
            return _serialize(changeset, items)

    def _apply_doc(self, session: Session, changeset: Changeset, item: ChangeItem) -> None:
        target = item.target
        if not target.endswith(".md") or target.startswith("/") or "\\" in target:
            raise PendingChangeError("Doc change target must be a Markdown file")
        parts = PurePosixPath(target).parts
        if not parts or ".." in parts:
            raise PendingChangeError("Doc change target escapes repository root")

        payload = item.payload or {}
        content = payload.get("content")
        if not isinstance(content, str) or not content.strip():
            raise PendingChangeError("Doc change payload.content must be a non-empty string")
        if not content.endswith("\n"):
            content += "\n"

        parsed = parse_frontmatter(target, content)
        title = DocsRepository._extract_title(parsed.body) or PurePosixPath(target).stem

        document = session.scalars(
            select(Document).where(Document.slug == target).with_for_update()
        ).first()
        if document is None:
            document = Document(slug=target, title=title)
            session.add(document)
            session.flush()
            version_no = 1
            parent_version_id = None
        else:
            if document.deleted_at is not None:
                raise PendingChangeError("Document is deleted")
            document.title = title
            latest = session.scalars(
                select(DocVersion)
                .where(DocVersion.document_id == document.id)
                .order_by(DocVersion.version_no.desc())
                .limit(1)
            ).first()
            version_no = (latest.version_no + 1) if latest else 1
            parent_version_id = latest.id if latest else None

        content_hash = _content_hash(content)
        if session.get(Blob, content_hash) is None:
            session.add(Blob(hash=content_hash, content=content, size=len(content)))

        session.add(
            DocVersion(
                document_id=document.id,
                version_no=version_no,
                parent_version_id=parent_version_id,
                content_hash=content_hash,
                raw=content,
                body=parsed.body,
                frontmatter=parsed.frontmatter,
                actor_kind="agent",
                actor_name=None,
                via=self.via,
                changeset_id=changeset.id,
            )
        )

    def _apply_inventory_item(
        self, session: Session, changeset: Changeset, item: ChangeItem
    ) -> None:
        parts = item.target.split("/")
        if len(parts) != 2 or not parts[0] or not parts[1]:
            raise PendingChangeError("Inventory item target must use '<inventory-type>/<id>'")
        inventory_type, item_id = parts

        inventory_type_row = session.get(InventoryType, inventory_type)
        if inventory_type_row is None:
            raise PendingChangeError("Inventory type not found")

        payload = item.payload or {}
        mode = payload.get("mode", "update")
        if mode not in {"update", "create"}:
            raise PendingChangeError("Inventory change mode must be 'update' or 'create'")

        if "patch" in payload:
            patch = payload["patch"]
        elif "mode" in payload:
            raise PendingChangeError("Inventory change payload.patch is required")
        else:
            patch = payload

        if not isinstance(patch, dict) or not patch:
            raise PendingChangeError("Inventory change patch must be a non-empty object")
        if "id" in patch:
            raise PendingChangeError("Inventory item id cannot be changed")

        row = session.scalars(
            select(InventoryItem)
            .where(
                InventoryItem.type == inventory_type,
                InventoryItem.item_id == item_id,
                InventoryItem.deleted_at.is_(None),
            )
            .with_for_update()
        ).first()

        if mode == "update":
            if row is None:
                raise PendingChangeError("Inventory item not found")
            row.data = {**dict(row.data or {}), **patch}
            latest = session.scalars(
                select(InventoryItemVersion)
                .where(InventoryItemVersion.inventory_item_id == row.id)
                .order_by(InventoryItemVersion.version_no.desc())
                .limit(1)
            ).first()
            version_no = (latest.version_no + 1) if latest else 1
            version_item = row
        else:
            if row is not None:
                raise PendingChangeError("Inventory item already exists")
            max_position = session.scalar(
                select(func.max(InventoryItem.position)).where(
                    InventoryItem.type == inventory_type
                )
            )
            row = InventoryItem(
                type=inventory_type,
                item_id=item_id,
                position=(max_position or 0) + 1,
                data=dict(patch),
            )
            session.add(row)
            session.flush()
            version_no = 1
            version_item = row

        session.add(
            InventoryItemVersion(
                inventory_item_id=version_item.id,
                version_no=version_no,
                data=dict(version_item.data or {}),
                changeset_id=changeset.id,
            )
        )

    @staticmethod
    def _changeset(session: Session, change_id: str) -> Changeset:
        try:
            identifier = UUID(str(change_id))
        except ValueError as exc:
            raise PendingChangeError("Pending change not found") from exc
        changeset = session.get(Changeset, identifier)
        if changeset is None:
            raise PendingChangeError("Pending change not found")
        return changeset

    @staticmethod
    def _items(session: Session, changeset_id: UUID) -> list[ChangeItem]:
        return list(
            session.scalars(
                select(ChangeItem)
                .where(ChangeItem.changeset_id == changeset_id)
                .order_by(ChangeItem.created_at, ChangeItem.id)
            ).all()
        )
