"""Merge requests as annotated tags under refs/tags/mr/."""

from __future__ import annotations

import json
import re
import secrets
from datetime import UTC, datetime
from enum import Enum
from typing import Any

from pygit2 import Commit, GitError, Oid, Repository, Signature, Tag, reference_is_valid_name
from pygit2.enums import MergeAnalysis

from pygittools.tasks import GIT_OBJECT_TAG, _build_tag_raw, _DateTimeEncoder

MR_REF_PREFIX: str = "refs/tags/mr/"


def generate_mr_ref() -> str:
    """Return ``refs/tags/mr/<16 hex chars>`` for distributed-safe ref names."""
    return f"{MR_REF_PREFIX}{secrets.token_hex(8)}"


def _parse_dt(value: Any) -> datetime | None:
    if not value:
        return None
    if isinstance(value, datetime):
        return value
    return datetime.fromisoformat(str(value).replace("Z", "+00:00"))


def _identity_from_opener(opener: Signature | str) -> tuple[str, str]:
    if isinstance(opener, Signature):
        return opener.name, opener.email
    line = (opener or "").strip()
    match = re.match(r"^(?P<name>.+) <(?P<email>[^>]+)>", line)
    if match:
        return match.group("name"), match.group("email")
    if line:
        return line, "unknown@local"
    return "unknown", "unknown@local"


def tagger_signature_at(opener: Signature | str, when: datetime) -> Signature:
    """Tagger line identity from ``opener`` with timestamp from ``when`` (UTC offset +0000)."""
    if when.tzinfo is None:
        when = when.replace(tzinfo=UTC)
    name, email = _identity_from_opener(opener)
    t = int(when.timestamp())
    return Signature(name, email, t, 0)


def assert_merge_head_object(repo: Repository, head: Oid | str) -> str:
    """Require the merge-request tag target to be a commit or tag object (not tree/blob)."""
    oid = head if isinstance(head, Oid) else Oid(hex=head)
    obj = repo[oid]
    type_str = (getattr(obj, "type_str", None) or "").lower()
    if type_str in ("blob", "tree"):
        raise ValueError(f"Merge request head must be a commit or tag, not {type_str}: {oid}")
    if type_str not in ("commit", "tag"):
        raise ValueError(f"Merge request head has unsupported type {type_str!r}: {oid}")
    return type_str


def peel_mr_head_to_commit_oid(repo: Repository, head: Oid | str) -> Oid:
    """Follow annotated tags until a commit OID (the revision to merge into ``ours``)."""
    oid = head if isinstance(head, Oid) else Oid(hex=head)
    cur = oid
    while True:
        try:
            obj = repo[cur]
        except KeyError as exc:
            raise KeyError(cur) from exc
        if isinstance(obj, Tag):
            cur = obj.target
            continue
        if isinstance(obj, Commit):
            return obj.id
        type_str = getattr(obj, "type_str", None) or type(obj).__name__
        raise TypeError(f"Merge request head peeled to non-commit ({type_str}): {cur}")


class MergeRequestStatus(Enum):
    OURS_REF_MISSING = "ours_ref_missing"
    MR_HEAD_MISSING = "mr_head_missing"
    CAN_FAST_FORWARD = "can_fast_forward"
    UP_TO_DATE = "up_to_date"
    BLOCKED_DIVERGED = "blocked_diverged"


"""
A MergeRequest is an annotated tag (and ref under refs/tags/mr/).
The tag points at the commit (or tag for merge-train) being merged.
The tag message is JSON with ours (branch receiving the merge), optional theirs (tracked branch tip),
title, description, comments, and timestamps.
The tagger line uses the opener's identity and the last-modified time from ``updated_at``.
"""


class MergeRequest:
    def __init__(
        self,
        target: Oid | str,
        opener: Signature | str,
        ours: str,
        title: str,
        description: str = "",
        theirs: str | None = None,
        name: str | None = None,
        comments: list[Oid | str] | None = None,
    ):
        ref_name = name if name is not None else generate_mr_ref()
        if not reference_is_valid_name(ref_name):
            raise ValueError(f"Invalid merge request ref name: {ref_name!r}")
        if not ours.strip():
            raise ValueError("ours must be a non-empty ref name")

        self.target = target
        self.opener = opener
        self.ours = ours.strip()
        self.theirs = theirs.strip() if theirs and str(theirs).strip() else None
        self.title = title
        self.description = description
        self.name = ref_name
        self.comments: list[Oid | str] = list(comments) if comments is not None else []
        self.created_at = datetime.now(UTC)
        self.updated_at = self.created_at
        self.message: str = ""
        self.update_message()

    def update_message(self) -> None:
        self.updated_at = datetime.now(UTC)
        payload: dict[str, Any] = {
            "title": self.title,
            "description": self.description,
            "ours": self.ours,
            "theirs": self.theirs,
            "comments": [str(c) for c in self.comments],
            "created_at": self.created_at,
            "updated_at": self.updated_at,
        }
        self.message = _DateTimeEncoder().encode(payload)

    def write(self, repo: Repository) -> Oid:
        object_type = assert_merge_head_object(repo, self.target)
        tagger_sig = tagger_signature_at(self.opener, self.updated_at)
        raw = _build_tag_raw(self.target, self.name, str(tagger_sig), self.message, object_type=object_type)
        oid = repo.odb.write(GIT_OBJECT_TAG, raw)
        repo.references.create(self.name, oid, force=True)
        return oid

    def refresh_from_theirs(self, repo: Repository) -> Oid | None:
        """If ``theirs`` is set, move tag target to that ref's peeled commit tip when it differs.
        Returns new tag OID if rewritten.
        """
        if not self.theirs:
            return None
        try:
            theirs_tip = repo.revparse_single(self.theirs).peel(Commit).id
        except (KeyError, ValueError, GitError):
            return None
        try:
            head_commit = peel_mr_head_to_commit_oid(repo, self.target)
        except KeyError:
            return None
        if head_commit == theirs_tip:
            return None
        self.target = theirs_tip
        self.update_message()
        return self.write(repo)

    def check_status(self, repo: Repository) -> MergeRequestStatus:
        try:
            repo.lookup_reference(self.ours)
        except KeyError:
            return MergeRequestStatus.OURS_REF_MISSING
        try:
            mr_commit = peel_mr_head_to_commit_oid(repo, self.target)
        except KeyError:
            return MergeRequestStatus.MR_HEAD_MISSING

        try:
            analysis, _pref = repo.merge_analysis(mr_commit, self.ours)
        except GitError as exc:
            raise ValueError(f"merge analysis failed for {self.ours!r}: {exc}") from exc

        if analysis & MergeAnalysis.FASTFORWARD:
            return MergeRequestStatus.CAN_FAST_FORWARD
        if analysis & MergeAnalysis.UP_TO_DATE:
            return MergeRequestStatus.UP_TO_DATE
        return MergeRequestStatus.BLOCKED_DIVERGED

    def merge(self, repo: Repository) -> MergeRequestStatus:
        status = self.check_status(repo)
        if status == MergeRequestStatus.OURS_REF_MISSING:
            raise ValueError(f"ours ref does not exist: {self.ours!r}")
        if status == MergeRequestStatus.MR_HEAD_MISSING:
            raise ValueError(f"merge request head object missing in repository: {self.target!r}")
        if status == MergeRequestStatus.BLOCKED_DIVERGED:
            raise ValueError(
                f"cannot fast-forward {self.ours!r} to merge request head {self.target!r}: histories diverged"
            )
        if status == MergeRequestStatus.UP_TO_DATE:
            return status

        mr_commit = peel_mr_head_to_commit_oid(repo, self.target)
        target_ref = repo.lookup_reference(self.ours).resolve()
        target_ref.set_target(mr_commit)
        return status


def _merge_request_from_tag(tag: Tag) -> MergeRequest:
    body = json.loads(tag.message)
    raw_ours = body.get("ours") or body.get("target")
    if raw_ours is None or not str(raw_ours).strip():
        raise ValueError("merge request payload missing non-empty ours (or legacy target)")
    theirs_raw = body.get("theirs")
    theirs = str(theirs_raw).strip() if theirs_raw is not None and str(theirs_raw).strip() else None
    mr = MergeRequest(
        tag.target,
        str(tag.tagger) if tag.tagger else "",
        ours=str(raw_ours).strip(),
        title=body.get("title", "Untitled"),
        description=body.get("description", ""),
        theirs=theirs,
        name=tag.name,
        comments=list(body.get("comments", [])),
    )
    mr.created_at = _parse_dt(body.get("created_at")) or mr.created_at
    mr.updated_at = _parse_dt(body.get("updated_at")) or mr.updated_at
    mr.message = tag.message
    return mr


def get_merge_request(repo: Repository, ref: str) -> MergeRequest:
    obj = repo.revparse_single(ref)
    if not isinstance(obj, Tag):
        raise ValueError(f"Requested merge request is not a tag: {ref}")
    return _merge_request_from_tag(obj)


def get_merge_request_by_oid(repo: Repository, oid: Oid) -> MergeRequest:
    obj = repo[oid]
    if not isinstance(obj, Tag):
        raise ValueError(f"Object is not a merge request tag: {oid}")
    return _merge_request_from_tag(obj)