import copy
from contextlib import closing
import json
from pathlib import Path
import tempfile
import unittest

import numpy as np

from segment_eq255 import (check_metadata, check_scope, check_totals, decode_frames, encode_frames, label_row,
                           new_metadata, scope_sequences, selected, LABEL)


def fixture():
    return {"dataset_id": "FreiHAND", "split": "train", "num_frames": 1,
            "components": {"mano": {"frozen": True}, "segment": {
                "schema_id": "segment/foreground_intensity/v1", "entity_id": "hand_right",
                "value_range": [0, 255], "normalization_scale": 1 / 255, "foreground_category": "hand",
                "valid_ref": "annotation/segment/mask_valid.pt", "provenance": {"kind": "format_conversion"},
                "storage": {"pixel_format": "gray", "codec": "ffv1", "source_lossy": True}}}}


class TestSelection(unittest.TestCase):
    def test_every_possible_value(self):
        a = np.arange(256, dtype=np.uint8).reshape(16, 16)
        b = selected(a)
        self.assertEqual(b.dtype, np.uint8)
        self.assertEqual(int(np.count_nonzero(b)), 1)
        self.assertEqual(b[-1, -1], 255)
        self.assertEqual(a[0, 1], 1)

    def test_widened_native_input(self):
        a = np.array([[0, 1, 127, 248, 254, 255]], dtype=np.uint16)
        np.testing.assert_array_equal(selected(a), [[0, 0, 0, 0, 0, 255]])

    def test_reject_scaling_or_float(self):
        for a in (np.array([[65535]], dtype=np.uint16), np.array([[1.0]], dtype=np.float32)):
            with self.assertRaises(ValueError):
                selected(a)

    def test_no_morphological_changes(self):
        a = np.array([[255, 254, 255], [255, 0, 255], [0, 255, 0]], dtype=np.uint8)
        np.testing.assert_array_equal(selected(a) == 255, a == 255)

    def test_zero_is_not_mapped_to_background(self):
        self.assertEqual(label_row(2, False), {"frame_index": 2, "labels": []})
        self.assertEqual(label_row(3, True)["labels"], [LABEL])
        self.assertEqual(LABEL["entity_id"], "hand_right")
        self.assertIsNone(LABEL["source_instance_id"])

    def test_metadata_only_segment(self):
        a = fixture()
        old = copy.deepcopy(a)
        b = new_metadata(a)
        self.assertEqual(a, old)
        check_metadata(a, b)
        self.assertEqual(b["components"]["segment"]["schema_id"], "segment/uint16_labels/v1")

    def test_other_annotation_mutation_rejected(self):
        a = fixture()
        b = new_metadata(a)
        b["components"]["mano"]["frozen"] = False
        with self.assertRaises(ValueError):
            check_metadata(a, b)

    def test_validity_reference_mutation_rejected(self):
        a = fixture()
        b = new_metadata(a)
        b["components"]["segment"]["valid_ref"] = "changed.pt"
        with self.assertRaises(ValueError):
            check_metadata(a, b)

    def test_eval_conversion_rejected(self):
        a = fixture()
        a["split"] = "test"
        a["components"]["segment"]["schema_id"] = "segment/uint16_labels/v1"
        with self.assertRaises(ValueError):
            new_metadata(a)

    def test_decoder_and_encoder_declarations_checked(self):
        a = fixture()
        for key, value in (("decoder", "scale gray8 to gray16le"),
                           ("encoder_parameters", {"level": 3, "threads": 1, "input_pixel_format": "gray16le"})):
            b = new_metadata(a)
            b["components"]["segment"]["storage"][key] = value
            with self.assertRaises(ValueError):
                check_metadata(a, b)

    def test_exact_pilot_and_full_scope(self):
        self.assertEqual(scope_sequences("pilot"), ["evaluation_00000000", "training_00000000", "training_00126976"])
        self.assertEqual(len(scope_sequences("all_33_shards")), 33)
        with self.assertRaises(ValueError):
            scope_sequences("invented")

    def test_partial_full_claim_rejected(self):
        with self.assertRaises(ValueError):
            check_scope(Path("/not-used"), {"scope": "all_33_shards", "sequences": ["training_00000000"]})

    def test_duplicate_or_missing_eval_rejected(self):
        for seqs in (["training_00000000", "training_00126976"], scope_sequences("pilot") + ["training_00000000"]):
            with self.assertRaises(ValueError):
                check_scope(Path("/not-used"), {"scope": "pilot", "sequences": seqs})

    def test_summary_recomputed(self):
        views = [{"frames": 5, "pixels_checked": 500, "empty_after_selection_frames": [2]}]
        good = {"training_frames": 5, "pixels_checked": 500, "empty_frames": 1}
        check_totals(good, views)
        for key in good:
            bad = good | {key: good[key] + 1}
            with self.assertRaises(ValueError):
                check_totals(bad, views)

    def test_lossless_gray8_video_roundtrip(self):
        a = np.arange(256, dtype=np.uint8).reshape(16, 16)
        frames = [selected(a), np.zeros_like(a), np.full_like(a, 255)]
        with tempfile.TemporaryDirectory() as d:
            path = Path(d) / "mask.mkv"
            encode_frames(path, iter(frames), 16, 16)
            with closing(decode_frames(path, "gray", 16, 16, 3)) as stream:
                actual = list(stream)
            for x, y in zip(frames, actual, strict=True):
                self.assertEqual(y.dtype, np.uint16)
                np.testing.assert_array_equal(x, y)
            with self.assertRaises(ValueError):
                with closing(decode_frames(path, "gray", 16, 16, 2)) as stream:
                    list(stream)
            with self.assertRaises(ValueError):
                with closing(decode_frames(path, "gray", 16, 16, 4)) as stream:
                    list(stream)


if __name__ == "__main__":
    unittest.main()