"""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, 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)