from __future__ import annotations

import difflib
from datetime import datetime
from typing import Any

from sqlalchemy import select
from sqlalchemy.orm import Session

from ..config import Settings
from ..pending_changes import ProposedChangeRequest
from .db import Database
from .models import Changeset, DocVersion, Document
from .pending_changes_db import PostgresPendingChangeRepository


class DocumentError(ValueError):
    pass


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


def _find_document(session: Session, path: str) -> Document:
    document = session.scalars(select(Document).where(Document.slug == path)).first()
    if document is None or document.deleted_at is not None:
        raise DocumentError("Document not found")
    return document


def _find_version(session: Session, document_id, version_no: int) -> DocVersion:
    version = session.scalars(
        select(DocVersion).where(
            DocVersion.document_id == document_id,
            DocVersion.version_no == version_no,
        )
    ).first()
    if version is None:
        raise DocumentError("Document version not found")
    return version


def list_document_versions(database: Database, path: str) -> list[dict[str, Any]]:
    with database.session() as session:
        document = _find_document(session, path)
        versions = session.scalars(
            select(DocVersion)
            .where(DocVersion.document_id == document.id)
            .order_by(DocVersion.version_no)
        ).all()

        result: list[dict[str, Any]] = []
        for version in versions:
            changeset = (
                session.get(Changeset, version.changeset_id)
                if version.changeset_id
                else None
            )
            result.append(
                {
                    "path": document.slug,
                    "version_no": version.version_no,
                    "content_hash": version.content_hash,
                    "created_at": _iso(version.created_at),
                    "actor_kind": version.actor_kind,
                    "actor_name": version.actor_name,
                    "via": version.via,
                    "changeset_id": str(version.changeset_id) if version.changeset_id else None,
                    "summary": changeset.summary if changeset else None,
                }
            )
        return result


def get_document_version(database: Database, path: str, version_no: int) -> dict[str, Any]:
    with database.session() as session:
        document = _find_document(session, path)
        version = _find_version(session, document.id, version_no)
        changeset = (
            session.get(Changeset, version.changeset_id) if version.changeset_id else None
        )
        return {
            "path": document.slug,
            "version_no": version.version_no,
            "raw": version.raw,
            "body": version.body,
            "frontmatter": dict(version.frontmatter or {}),
            "content_hash": version.content_hash,
            "created_at": _iso(version.created_at),
            "actor_kind": version.actor_kind,
            "actor_name": version.actor_name,
            "via": version.via,
            "changeset_id": str(version.changeset_id) if version.changeset_id else None,
            "summary": changeset.summary if changeset else None,
        }


def diff_document_versions(
    database: Database,
    path: str,
    from_version: int | None = None,
    to_version: int | None = None,
) -> dict[str, Any]:
    with database.session() as session:
        document = _find_document(session, path)
        versions = session.scalars(
            select(DocVersion)
            .where(DocVersion.document_id == document.id)
            .order_by(DocVersion.version_no)
        ).all()
        if not versions:
            raise DocumentError("Document has no versions")

        latest_no = versions[-1].version_no
        target_no = latest_no if to_version is None else to_version
        if from_version is None:
            source_no = max(1, target_no - 1)
        else:
            source_no = from_version

        if source_no < 1 or target_no < 1:
            raise DocumentError("Version numbers must be positive")

        source = _find_version(session, document.id, source_no)
        target = _find_version(session, document.id, target_no)

        diff_lines = difflib.unified_diff(
            source.raw.splitlines(),
            target.raw.splitlines(),
            fromfile=f"{path}@v{source_no}",
            tofile=f"{path}@v{target_no}",
            lineterm="",
        )
        return {
            "path": path,
            "from_version": source_no,
            "to_version": target_no,
            "diff": "\n".join(diff_lines),
        }


def restore_document_version(
    database: Database,
    settings: Settings,
    path: str,
    version_no: int,
    summary: str | None = None,
    via: str = "api",
) -> dict[str, Any]:
    with database.session() as session:
        document = _find_document(session, path)
        version = _find_version(session, document.id, version_no)
        raw = version.raw

    repository = PostgresPendingChangeRepository(database, settings, via=via)
    change = repository.create(
        ProposedChangeRequest(
            kind="doc",
            target=path,
            summary=summary or f"Restore {path} to version {version_no}",
            reason=f"Restore version {version_no}",
            payload={"content": raw},
        )
    )
    return repository.apply(change["id"])
