import os
import json
from pathlib import Path
from typing import Dict, Any, List, Union, Iterator, Tuple

import datasets
from datasets.download.download_manager import DownloadManager, ArchiveIterable

# Typing
_TYPING_BOX = Tuple[float, float, float, float]

_DESCRIPTION = """\
Training image sets and labels/bounding box coordinates for detecting brain
tumors in MR images.
- The datasets JPGs exported at their native size and are separated by plan
(Axial, Coronal and Sagittal).
- Tumors were hand labeled using https://makesense.ai
- Bounding box coordinates and MGMT positive labels were marked on ~400 images
for each plane in the T1wCE series from the RSNA-MICCAI competition data.
"""

_URLS = {
    "train": "https://huggingface.co/datasets/chanelcolgate/tumorsbrain/resolve/main/data/train.zip",
    "test": "https://huggingface.co/datasets/chanelcolgate/tumorsbrain/resolve/main/data/test.zip",
    "annotations": "https://huggingface.co/datasets/chanelcolgate/tumorsbrain/resolve/main/data/annotations.zip",
}

_PATHS = {
    "annotations": {
        "train": Path("_annotations.coco.train.json"),
        "test": Path("_annotations.coco.test.json"),
    },
    "images": {"train": Path("train"), "test": Path("test")},
}

_CLASSES = ["negative", "positive"]

_SPLITS = ["train", "test"]


def round_box_values(box, decimals=2):
    return [round(val, decimals) for val in box]


class COCOHelper:
    """Helper class to load COCO annotations"""

    def __init__(self, annotation_path: Path, images_dir: Path) -> None:
        with open(annotation_path, "r") as file:
            data = json.load(file)
        self.data = data

        dict_id2annot: Dict[int, Any] = {}
        for annot in self.annotations:
            dict_id2annot.setdefault(annot["image_id"], []).append(annot)

        # Sort by id
        dict_id2annot = {
            k: list(sorted(v, key=lambda a: a["id"]))
            for k, v in dict_id2annot.items()
        }

        self.dict_path2annot: Dict[str, Any] = {}
        self.dict_path2id: Dict[str, Any] = {}
        for img in self.images:
            path_img = images_dir / str(img["file_name"])
            path_img_str = str(path_img)
            idx = int(img["id"])
            annot = dict_id2annot.get(idx, [])
            self.dict_path2annot[path_img_str] = annot
            self.dict_path2id[path_img_str] = img["id"]

    def __len__(self) -> int:
        return len(self.data["images"])

    @property
    def images(self) -> List[Dict[str, Union[str, int]]]:
        return self.data["images"]

    @property
    def annotations(self) -> List[Any]:
        return self.data["annotations"]

    @property
    def categories(self) -> List[Dict[str, Union[str, int]]]:
        return self.data["categories"]

    def get_annotations(self, image_path: str) -> List[Any]:
        return self.dict_path2annot.get(image_path, [])

    def get_image_id(self, image_path: str) -> int:
        return self.dict_path2id.get(image_path, -1)


class COCOThienviet(datasets.GeneratorBasedBuilder):
    """COCO Thienviet dataset."""

    VERSION = datasets.Version("1.0.1")

    def _info(self) -> datasets.DatasetInfo:
        """
        Return the dataset metadata and features.

        Returns:
            DatasetInfo: Metadata and features of the dataset.
        """
        return datasets.DatasetInfo(
            description=_DESCRIPTION,
            features=datasets.Features(
                {
                    "image": datasets.Image(),
                    "image_id": datasets.Value("int64"),
                    "objects": datasets.Sequence(
                        {
                            "id": datasets.Value("int64"),
                            "area": datasets.Value("float64"),
                            "bbox": datasets.Sequence(
                                datasets.Value("float32"), length=4
                            ),
                            "label": datasets.ClassLabel(names=_CLASSES),
                            "iscrowd": datasets.Value("bool"),
                        }
                    ),
                }
            ),
        )

    def _split_generators(
        self, dl_manager: DownloadManager
    ) -> List[datasets.SplitGenerator]:
        """
        Provides the split information and downloads the data.

        Args:
            dl_manager (DownloadManager): The DownloadManager to use for
                downloading and extracting data.

        Returns:
            List[SplitGenerator]: List of SplitGenerator objects representing
                the data splits.
        """
        archive_annots = dl_manager.download_and_extract(_URLS["annotations"])

        splits = []
        for split in _SPLITS:
            archive_split = dl_manager.download(_URLS[split])
            annotation_path = (
                Path(archive_annots) / _PATHS["annotations"][split]
            )
            images = dl_manager.iter_archive(archive_split)
            if split == "train":
                splits.append(
                    datasets.SplitGenerator(
                        name=datasets.Split.TRAIN,
                        gen_kwargs={
                            "annotation_path": annotation_path,
                            "images_dir": _PATHS["images"][split],
                            "images": images,
                        },
                    )
                )
            else:
                splits.append(
                    datasets.SplitGenerator(
                        name=datasets.Split.TEST,
                        gen_kwargs={
                            "annotation_path": annotation_path,
                            "images_dir": _PATHS["images"][split],
                            "images": images,
                        },
                    )
                )
        return splits

    def _generate_examples(
        self, annotation_path: Path, images_dir: Path, images: ArchiveIterable
    ) -> Iterator:
        """
        Generates examples for the dataset.

        Args:
            annotation_path (Path): The path to the annotation file.
            images_dir (Path): The path to the directory containing the images.
            images: (ArchiveIterable): An iterable containing the images.

        Yields:
            Dict[str, Union[str, Image]]: A dictionary containing the
                generated examples.
        """
        coco_annotation = COCOHelper(annotation_path, images_dir)

        for image_path, f in images:
            annotations = coco_annotation.get_annotations(
                os.path.normpath(image_path)
            )
            ret = {
                "image": {"path": image_path, "bytes": f.read()},
                "image_id": coco_annotation.get_image_id(
                    os.path.normpath(image_path)
                ),
                "objects": [
                    {
                        "id": annot["id"],
                        "area": annot["area"],
                        "bbox": round_box_values(
                            annot["bbox"], 2
                        ),  # [x, y, w, h]
                        "label": annot["category_id"],
                        "iscrowd": bool(annot["iscrowd"]),
                    }
                    for annot in annotations
                ],
            }
            yield image_path, ret