from __future__ import annotations

from dataclasses import asdict, dataclass, field, replace
import hashlib
import json
import os
from pathlib import Path
from typing import Any, Iterable, Mapping
from uuid import uuid4
import tempfile


@dataclass(frozen=True)
class Box:
    """Pallet bounding box in pixel coordinates, XYWH."""
    x: float
    y: float
    width: float
    height: float

    def validate(self, image_width: int, image_height: int) -> None:
        vals = (self.x, self.y, self.width, self.height)
        if not all(float(v) == v and abs(v) != float("inf") for v in vals):
            raise ValueError("box coordinates must be finite numbers")
        if self.width <= 0 or self.height <= 0 or self.x < 0 or self.y < 0:
            raise ValueError("box must have positive size and nonnegative origin")
        if self.x + self.width > image_width or self.y + self.height > image_height:
            raise ValueError("box extends outside image")


@dataclass(frozen=True)
class Provenance:
    source: str  # human, sam3, detector, imported
    actor: str = ""
    model: str = ""
    created_at: str = ""
    trained_group_ids: tuple[str, ...] = ()
    note: str = ""


@dataclass(frozen=True)
class SceneAttributes:
    domain: str = "unknown"
    lighting: str = "unknown"
    occlusion: str = "unknown"
    viewpoint: str = "unknown"
    distance: str = "unknown"
    surface: str = "unknown"
    tags: tuple[str, ...] = ()


@dataclass(frozen=True)
class Review:
    reviewer: str
    decision: str  # approve, reject, needs_work
    reviewed_at: str = ""
    note: str = ""
    blind: bool = True
    status: str | None = None
    boxes: tuple[Box, ...] | None = None
    annotation_digest: str = ""
    review_id: str = ""
    adjudicates: tuple[str, ...] = ()
    scene_tags: tuple[str, ...] | None = None
    ignore_regions: tuple[Box, ...] | None = None


@dataclass
class FrameAnnotation:
    frame_id: str
    group_id: str
    image: str
    width: int
    height: int
    status: str = "unreviewed"  # pos, negative, ignore, unreviewed
    boxes: list[Box] = field(default_factory=list)
    scene: SceneAttributes = field(default_factory=SceneAttributes)
    provenance: list[Provenance] = field(default_factory=list)
    reviews: list[Review] = field(default_factory=list)
    split: str | None = None
    domain: str = "unknown"
    dimensions_pending: bool = False
    evidence_images: list[str] = field(default_factory=list)
    source_anchor_hash: str = ""
    ignore_regions: list[Box] = field(default_factory=list)

    def validate(self) -> None:
        if not self.frame_id or not self.group_id or not self.image:
            raise ValueError("frame_id, group_id and image are required")
        if self.width <= 0 or self.height <= 0:
            raise ValueError("image dimensions must be positive")
        if self.dimensions_pending and self.boxes:
            raise ValueError("cannot annotate until visualization dimensions are known")
        if self.status not in {"pos", "negative", "ignore", "unreviewed"}:
            raise ValueError(f"invalid annotation status: {self.status}")
        if self.status == "pos" and not self.boxes:
            raise ValueError("positive frame must contain at least one pallet box")
        if self.status in {"negative", "ignore"} and self.boxes:
            raise ValueError(f"{self.status} frames cannot contain boxes")
        for box in self.boxes:
            box.validate(self.width, self.height)
        for region in self.ignore_regions:
            region.validate(self.width,self.height)
        if self.ignore_regions and self.status!='pos':
            raise ValueError('partial ignore regions require at least one confirmed positive instance')


def annotation_digest(frame: FrameAnnotation) -> str:
    """Hash the final reference payload; review history and notes are excluded."""
    payload = {"frame_id": frame.frame_id, "group_id": frame.group_id,
               "split": frame.split, "source_anchor_hash": frame.source_anchor_hash,
               "status": frame.status, "boxes": [asdict(box) for box in frame.boxes],
               "width": frame.width, "height": frame.height,
               "scene_tags": list(frame.scene.tags)}
    if frame.ignore_regions:
        payload['ignore_regions']=[asdict(box) for box in frame.ignore_regions]
    encoded = json.dumps(payload, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()


def _matches_payload(review: Review, frame: FrameAnnotation, digest: str) -> bool:
    return (review.annotation_digest == digest and review.status == frame.status
            and review.boxes is not None and list(review.boxes) == frame.boxes
            and list(review.ignore_regions or ())==frame.ignore_regions)


def is_resolved(frame: FrameAnnotation, *, require_blind: bool = False) -> bool:
    """Require current-payload approvals or explicit adjudication of two proposals."""
    try:
        frame.validate()
    except ValueError:
        return False
    if frame.status not in {"pos", "negative", "ignore"} or not frame.source_anchor_hash:
        return False
    if require_blind and not reference_eligible(frame, check_resolved=False):
        return False
    digest = annotation_digest(frame)
    valid = [review for review in frame.reviews
             if _matches_payload(review, frame, digest)
             and (review.blind or not require_blind)]
    approvals = {review.reviewer for review in valid if review.decision == "approve"}
    if len(approvals) >= 2:
        return True
    by_id = {review.review_id: review for review in frame.reviews if review.review_id}
    for adjudication in valid:
        if adjudication.decision != "adjudicate" or len(set(adjudication.adjudicates)) < 2:
            continue
        proposals = [by_id.get(review_id) for review_id in adjudication.adjudicates]
        proposals = [review for review in proposals if review is not None and
                     review.status in {"pos", "negative", "ignore"} and review.boxes is not None and
                     review.reviewer != adjudication.reviewer and
                     review.annotation_digest == annotation_digest(replace(frame, status=review.status, boxes=list(review.boxes),
                         ignore_regions=list(review.ignore_regions or ()),
                         scene=replace(frame.scene, tags=review.scene_tags or ()))) and
                     (review.blind or not require_blind)]
        if len({review.reviewer for review in proposals}) >= 2:
            return True
    return False


def reference_eligible(frame: FrameAnnotation, *, check_resolved: bool = True) -> bool:
    """Reject assisted validation/test references, including after a split changes."""
    if frame.split in {"val", "test"}:
        if any(p.source.lower() in {"detector", "fewshot", "sam3", "model", "segmentation"}
               for p in frame.provenance):
            return False
        if any(not review.blind for review in frame.reviews):
            return False
    return is_resolved(frame) if check_resolved else True


class AnnotationSet:
    """In-memory frame index with JSONL persistence and annotation QA."""
    def __init__(self, frames: Iterable[FrameAnnotation] = ()):
        self.frames: dict[str, FrameAnnotation] = {}
        for frame in frames:
            self.add(frame)

    def add(self, frame: FrameAnnotation, *, replace: bool = False) -> None:
        frame.validate()
        if frame.frame_id in self.frames and not replace:
            raise ValueError(f"duplicate frame_id: {frame.frame_id}")
        self.frames[frame.frame_id] = frame

    def unresolved(self) -> list[FrameAnnotation]:
        return unresolved(self)

    def qa(self) -> dict[str, Any]:
        return qa_report(self)


def unresolved(dataset: AnnotationSet) -> list[FrameAnnotation]:
    return sorted((f for f in dataset.frames.values() if not reference_eligible(f)),
                  key=lambda f: f.frame_id)


def qa_report(dataset: AnnotationSet) -> dict[str, Any]:
    counts = {s: 0 for s in ("pos", "negative", "ignore", "unreviewed")}
    problems: list[str] = []
    for frame in dataset.frames.values():
        try:
            frame.validate()
        except ValueError as exc:
            problems.append(f"{frame.frame_id}: {exc}")
        counts[frame.status] = counts.get(frame.status, 0) + 1
        if frame.dimensions_pending and frame.status != "ignore":
            problems.append(f"{frame.frame_id}: visualization dimensions are pending")
        digest = annotation_digest(frame)
        reviewers = [r.reviewer for r in frame.reviews if r.annotation_digest == digest]
        if len(reviewers) != len(set(reviewers)):
            problems.append(f"{frame.frame_id}: duplicate current-payload reviewer")
    disputed = sum(any(review.decision != "approve" for review in frame.reviews)
                   for frame in dataset.frames.values())
    return {"frames": len(dataset.frames), "status_counts": counts,
            "disputed": disputed,
            "unresolved": len(unresolved(dataset)), "problems": problems}


def create_proposals(records: Iterable[Any], *, image_sizes: Mapping[str, tuple[int, int]] | None = None,
                     source: str = "human", actor: str = "", domain: str = "unknown") -> AnnotationSet:
    """Create blank records from `scan_dataset` rows (frame_id/group_id/paths).

    `image_sizes` keys describe an explicitly registered visualization grid.
    A PCD is the geometry anchor whenever present. Raster dimensions alone do
    not prove alignment; RGB is retained only as side-view evidence.
    """
    output = AnnotationSet()
    for rec in records:
        fid = rec.frame_id
        paths = getattr(rec, "paths", {})
        def raster(key: str) -> Path | None:
            candidate = paths.get(key)
            if candidate is not None and Path(candidate).suffix.lower() in {".png", ".jpg", ".jpeg"}:
                return Path(candidate)
            return None

        depth_path = raster("depth")
        intensity_path = raster("intensity")
        pcd_path = paths.get("pcd")
        pcd_grid = None
        if pcd_path is not None:
            try:
                from pallet.data.manifest import _pcd_grid
                pcd_grid = _pcd_grid(pcd_path)  # (height, width), header only
            except (OSError, ValueError, KeyError):
                pass

        def raster_size(candidate: Path | None) -> tuple[int, int] | None:
            if candidate is None:
                return None
            try:
                from PIL import Image
                with Image.open(candidate) as image_handle:
                    return image_handle.size
            except (OSError, ValueError):
                return None

        depth_size = raster_size(depth_path)
        intensity_size = raster_size(intensity_path)
        policy = getattr(rec, "sensor_config", None) or {}
        width_height = (image_sizes or {}).get(fid)
        image_path: Path | None = None
        if pcd_path is not None:
            if pcd_grid:
                native = (pcd_grid[1], pcd_grid[0])
                if width_height is not None and width_height != native:
                    raise ValueError(f"visualization grid differs from PCD native grid: {fid}")
                width_height = native
            if policy.get("rasters_aligned") and width_height is not None:
                if depth_size == width_height:
                    image_path = depth_path
                elif intensity_size == width_height:
                    image_path = intensity_path
        elif width_height is None:
            if depth_size:
                image_path, width_height = depth_path, depth_size
            elif intensity_size:
                image_path, width_height = intensity_path, intensity_size
        elif depth_size == width_height:
            image_path = depth_path
        elif intensity_size == width_height:
            image_path = intensity_path
        if width_height is None:
            width_height = (1, 1)
            pending = True
        else:
            pending = False
        image = str(image_path or pcd_path or f"{fid}.visualization")
        evidence = [str(paths[key]) for key in ("rgb", "depth", "intensity")
                    if paths.get(key) is not None and str(paths[key]) != image]
        width, height = width_height
        anchor = getattr(rec, "source_sha256", None) if pcd_path is not None else None
        anchor_path = Path(pcd_path) if pcd_path is not None else image_path
        if not anchor and anchor_path is not None and anchor_path.is_file():
            hasher = hashlib.sha256()
            with anchor_path.open("rb") as source_file:
                for chunk in iter(lambda: source_file.read(1024 * 1024), b""):
                    hasher.update(chunk)
            anchor = hasher.hexdigest()
        output.add(FrameAnnotation(fid, rec.group_id, image, width, height,
                                   provenance=[Provenance(source, actor)], domain=domain,
                                   dimensions_pending=pending, evidence_images=evidence,
                                   source_anchor_hash=anchor or ""))
    return output


def merge_proposals(dataset: AnnotationSet, proposals: Mapping[str, Iterable[Box]], *,
                    provenance: Provenance, split_assignments: Mapping[str, str] | None = None) -> None:
    """Attach candidate boxes to unresolved records without marking them truth.

    Detector outputs trained on any sealed test group are rejected. All detector
    outputs for test groups are rejected, even if their declared training set is
    disjoint, so blind test annotations cannot be generated by that detector.
    """
    assignments = split_assignments or {}
    if provenance.source in {"detector", "fewshot", "sam3", "model", "segmentation"}:
        test_groups = {f.group_id for f in dataset.frames.values()
                       if assignments.get(f.group_id, f.split) == "test"}
        overlap = test_groups.intersection(provenance.trained_group_ids)
        if overlap:
            raise ValueError("detector was trained on sealed test groups")
        blind_frames = {fid for fid, f in dataset.frames.items()
                        if assignments.get(f.group_id, f.split) in {"val", "test"}}
        if blind_frames.intersection(proposals):
            raise ValueError("assisted proposals cannot be added to blind validation/test frames")
    for fid, boxes in proposals.items():
        if fid not in dataset.frames:
            raise KeyError(f"unknown frame_id: {fid}")
        frame = dataset.frames[fid]
        if frame.status != "unreviewed":
            raise ValueError(f"cannot overwrite adjudicated frame: {fid}")
        if frame.dimensions_pending:
            raise ValueError(f"visualization dimensions are pending for frame: {fid}")
        candidate_boxes = list(boxes)
        for box in candidate_boxes:
            box.validate(frame.width, frame.height)
        frame.boxes = candidate_boxes
        frame.provenance.append(provenance)


def record_review(frame: FrameAnnotation, review: Review, *, status: str | None = None,
                  boxes: Iterable[Box] | None = None, scene: SceneAttributes | None = None,
                  ignore_regions: Iterable[Box] | None = None) -> None:
    """Validate and bind a review before mutating the frame."""
    from pallet.data.eligibility import annotation_record, require_eligible
    require_eligible(annotation_record(frame))
    if frame.split in {"val", "test"} and (not review.blind or
            any(p.source.lower() in {"detector", "fewshot", "sam3", "model", "segmentation"}
                for p in frame.provenance)):
        raise ValueError("validation and test reference review must be blind to proposals")
    if review.decision not in {"approve", "reject", "needs_work", "adjudicate"}:
        raise ValueError("invalid review decision")
    next_status = status if status is not None else (review.status if review.status is not None else frame.status)
    next_boxes = list(boxes) if boxes is not None else (list(review.boxes) if review.boxes is not None else (
        [] if next_status in {"negative", "ignore"} else list(frame.boxes)))
    next_scene = scene if scene is not None else frame.scene
    next_ignore=list(ignore_regions) if ignore_regions is not None else list(review.ignore_regions or ())
    candidate = replace(frame, status=next_status, boxes=next_boxes, scene=next_scene,ignore_regions=next_ignore)
    candidate.validate()
    candidate_digest = annotation_digest(candidate)
    if any(r.reviewer == review.reviewer and r.annotation_digest == candidate_digest
           for r in frame.reviews):
        raise ValueError("reviewer must be independent for the current annotation")
    if review.status is not None and review.status != candidate.status and review.decision in {"approve", "adjudicate"}:
        raise ValueError("review status differs from final annotation")
    explicit_boxes = tuple(review.boxes) if review.boxes is not None else tuple(next_boxes)
    if review.decision in {"approve", "adjudicate"} and list(explicit_boxes) != next_boxes:
        raise ValueError("review boxes differ from final annotation")
    for box in explicit_boxes:
        box.validate(candidate.width, candidate.height)
    if review.decision == "adjudicate" and len(set(review.adjudicates)) < 2:
        raise ValueError("adjudication requires two independent proposal review IDs")
    if review.decision == 'adjudicate':
        by_id = {r.review_id: r for r in frame.reviews if r.review_id}
        proposals = [by_id.get(key) for key in review.adjudicates]
        if any(r is None or r.status not in {'pos','negative','ignore'} or r.boxes is None
               or r.reviewer == review.reviewer for r in proposals):
            raise ValueError('adjudication must refer to existing independent bound proposals')
        if len({r.reviewer for r in proposals}) < 2:
            raise ValueError('adjudication requires two distinct independent reviewers')
        for proposal in proposals:
            expected = annotation_digest(replace(candidate,status=proposal.status,boxes=list(proposal.boxes),
                                                 ignore_regions=list(proposal.ignore_regions or ()),
                                                 scene=replace(candidate.scene,tags=proposal.scene_tags or ())))
            if proposal.annotation_digest != expected:
                raise ValueError('proposal binding is stale for the current source/split/tags')
    bound = replace(review, status=review.status or candidate.status, boxes=explicit_boxes,
                    annotation_digest=candidate_digest,
                    review_id=review.review_id or uuid4().hex,
                    scene_tags=tuple(candidate.scene.tags),ignore_regions=tuple(candidate.ignore_regions))
    frame.status, frame.boxes, frame.scene = candidate.status, candidate.boxes, candidate.scene
    frame.ignore_regions=candidate.ignore_regions
    frame.reviews.append(bound)


def seal_splits(dataset: AnnotationSet, assignments: Mapping[str, str]) -> None:
    """Assign group-level train/val/test splits and check source-domain leakage."""
    valid = {"train", "val", "test"}
    unknown = set(assignments.values()) - valid
    if unknown:
        raise ValueError(f"invalid splits: {sorted(unknown)}")
    for frame in dataset.frames.values():
        assigned = assignments.get(frame.group_id)
        if assigned is not None and frame.split is not None and frame.split != assigned:
            raise ValueError(f"split is already sealed for group {frame.group_id}: {frame.split}")
    for frame in dataset.frames.values():
        if frame.group_id not in assignments:
            raise ValueError(f"missing split for group {frame.group_id}")
        split = assignments[frame.group_id]
    for frame in dataset.frames.values():
        frame.split = assignments[frame.group_id]


def _serialize(frame: FrameAnnotation) -> dict[str, Any]:
    return asdict(frame)


def save_jsonl(dataset: AnnotationSet, path: str | Path) -> None:
    path = Path(path)
    path.parent.mkdir(parents=True, exist_ok=True)
    with tempfile.NamedTemporaryFile('w',encoding='utf-8',dir=path.parent,
                                     prefix=path.name+'.',suffix='.tmp',delete=False) as stream:
        temporary=Path(stream.name)
        for frame in sorted(dataset.frames.values(), key=lambda f: f.frame_id):
            stream.write(json.dumps(_serialize(frame), sort_keys=True) + "\n")
    os.replace(temporary, path)


def load_jsonl(path: str | Path) -> AnnotationSet:
    frames = []
    for line_no, line in enumerate(Path(path).open(encoding="utf-8"), 1):
        if not line.strip():
            continue
        try:
            row = json.loads(line)
            row["boxes"] = [Box(**b) for b in row.get("boxes", [])]
            row['ignore_regions']=[Box(**b) for b in row.get('ignore_regions',[])]
            row["scene"] = SceneAttributes(**row.get("scene", {}))
            row["provenance"] = [Provenance(**p) for p in row.get("provenance", [])]
            row["reviews"] = [Review(**{**r,
                "boxes": tuple(Box(**box) for box in r["boxes"]) if r.get("boxes") is not None else None,
                "adjudicates": tuple(r.get("adjudicates", ())),
                "scene_tags": tuple(r['scene_tags']) if r.get('scene_tags') is not None else None})
                if not r.get('ignore_regions') else Review(**{**r,
                  'boxes':tuple(Box(**box) for box in r['boxes']) if r.get('boxes') is not None else None,
                  'adjudicates':tuple(r.get('adjudicates',())),
                  'scene_tags':tuple(r['scene_tags']) if r.get('scene_tags') is not None else None,
                  'ignore_regions':tuple(Box(**box) for box in r['ignore_regions'])})
                for r in row.get("reviews", [])]
            # JSON arrays map back to immutable tuple fields.
            row["provenance"] = [Provenance(**{**asdict(p), "trained_group_ids": tuple(p.trained_group_ids)}) for p in row["provenance"]]
            row["scene"] = SceneAttributes(**{**asdict(row["scene"]), "tags": tuple(row["scene"].tags)})
            frames.append(FrameAnnotation(**row))
        except (TypeError, ValueError, KeyError) as exc:
            raise ValueError(f"invalid annotation JSONL line {line_no}: {exc}") from exc
    return AnnotationSet(frames)


def export_coco(dataset: AnnotationSet, path: str | Path | None = None, *,
                audit: bool = False) -> dict[str, Any]:
    """Export resolved references, or all records with ``audit=True``."""
    images, annotations = [], []
    selected = sorted(dataset.frames.values(), key=lambda f: f.frame_id)
    if not audit:
        from pallet.data.eligibility import annotation_eligible
        selected = [frame for frame in selected if annotation_eligible(frame)]
        selected = [frame for frame in selected if frame.status in {'pos','negative'} and reference_eligible(frame)]
    for image_id, frame in enumerate(selected, 1):
        image = {"id": image_id, "file_name": frame.image, "width": frame.width,
                 "height": frame.height, "frame_id": frame.frame_id,
                 "group_id": frame.group_id, "split": frame.split,
                 "status": frame.status, "domain": frame.domain,
                 "resolved": is_resolved(frame),
                 "reference_eligible": reference_eligible(frame),
                 "source_anchor_hash": frame.source_anchor_hash,
                 "annotation_digest": annotation_digest(frame),
                 "evidence_images": list(frame.evidence_images),
                 'ignore_regions':[asdict(region) for region in frame.ignore_regions],
                 "scene": asdict(frame.scene), "provenance": [asdict(p) for p in frame.provenance],
                 "reviews": [asdict(r) for r in frame.reviews]}
        if audit and not reference_eligible(frame):
            image["candidate_boxes"] = [asdict(box) for box in frame.boxes]
        images.append(image)
        for box in frame.boxes if reference_eligible(frame) else []:
            annotations.append({"id": len(annotations) + 1, "image_id": image_id,
                                "category_id": 1, "bbox": [box.x, box.y, box.width, box.height],
                                "area": box.width * box.height, "iscrowd": 0})
        if reference_eligible(frame):
            for region in frame.ignore_regions:
                annotations.append({'id':len(annotations)+1,'image_id':image_id,'category_id':1,
                    'bbox':[region.x,region.y,region.width,region.height],'area':region.width*region.height,
                    'iscrowd':1,'ignore':1})
    payload = {"images": images, "annotations": annotations,
               "categories": [{"id": 1, "name": "pallet", "supercategory": "object"}],
               "info": {"single_class": True, "negative_ignore_statuses": ["negative", "ignore"]}}
    if path is not None:
        Path(path).write_text(json.dumps(payload, indent=2), encoding="utf-8")
    return payload


def export_audit(dataset: AnnotationSet, path: str | Path | None = None) -> dict[str, Any]:
    """Export full frame history without turning proposal boxes into references."""
    return export_coco(dataset, path, audit=True)


def export_yolo(dataset: AnnotationSet, directory: str | Path) -> list[Path]:
    """Write one YOLO label text per frame; status sidecar preserves empties."""
    directory = Path(directory)
    directory.mkdir(parents=True, exist_ok=True)
    outputs = []
    for frame in sorted(dataset.frames.values(), key=lambda f: f.frame_id):
        from pallet.data.eligibility import annotation_eligible
        if not annotation_eligible(frame):
            continue
        if frame.status in {"ignore", "unreviewed"} or frame.ignore_regions or not reference_eligible(frame):
            continue
        stem = frame.frame_id.replace("/", "__")
        label = directory / f"{stem}.txt"
        rows = []
        for box in frame.boxes:
            cx = (box.x + box.width / 2) / frame.width
            cy = (box.y + box.height / 2) / frame.height
            rows.append(f"0 {cx:.8f} {cy:.8f} {box.width/frame.width:.8f} {box.height/frame.height:.8f}")
        label.write_text("\n".join(rows) + ("\n" if rows else ""), encoding="utf-8")
        (directory / f"{stem}.json").write_text(json.dumps({
            "frame_id": frame.frame_id, "group_id": frame.group_id, "status": frame.status,
            "split": frame.split, "domain": frame.domain,
        }, sort_keys=True), encoding="utf-8")
        outputs.append(label)
    return outputs
