import json
import pathlib
from collections import defaultdict
from dataclasses import asdict, dataclass
from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union

import datasets as ds
import numpy as np
from datasets.utils.logging import get_logger
from PIL import Image
from PIL.Image import Image as PilImage
from pycocotools import mask as cocomask
from tqdm.auto import tqdm

logger = get_logger(__name__)

JsonDict = Dict[str, Any]
ImageId = int
AnnotationId = int
LicenseId = int
CategoryId = int
Bbox = Tuple[float, float, float, float]

_DESCRIPTION = """\
PubLayNet is a dataset for document layout analysis. It contains images of research papers and articles and annotations for various elements in a page such as "text", "list", "figure" etc in these research paper images. The dataset was obtained by automatically matching the XML representations and the content of over 1 million PDF articles that are publicly available on PubMed Central.
"""

_CITATION = """\
@inproceedings{zhong2019publaynet,
  title={Publaynet: largest dataset ever for document layout analysis},
  author={Zhong, Xu and Tang, Jianbin and Yepes, Antonio Jimeno},
  booktitle={2019 International Conference on Document Analysis and Recognition (ICDAR)},
  pages={1015--1022},
  year={2019},
  organization={IEEE}
}
"""

_HOMEPAGE = "https://developer.ibm.com/exchanges/data/all/publaynet/"

_LICENSE = "CDLA-Permissive"

_URL = "https://dax-cdn.cdn.appdomain.cloud/dax-publaynet/1.0.0/publaynet.tar.gz"


class UncompressedRLE(TypedDict):
    counts: List[int]
    size: Tuple[int, int]


class CompressedRLE(TypedDict):
    counts: bytes
    size: Tuple[int, int]


@dataclass
class CategoryData(object):
    category_id: int
    name: str
    supercategory: str

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "CategoryData":
        return cls(
            category_id=json_dict["id"],
            name=json_dict["name"],
            supercategory=json_dict["supercategory"],
        )


@dataclass
class ImageData(object):
    image_id: ImageId
    file_name: str
    width: int
    height: int

    @classmethod
    def from_dict(cls, json_dict: JsonDict) -> "ImageData":
        return cls(
            image_id=json_dict["id"],
            file_name=json_dict["file_name"],
            width=json_dict["width"],
            height=json_dict["height"],
        )

    @property
    def shape(self) -> Tuple[int, int]:
        return (self.height, self.width)


@dataclass
class AnnotationData(object):
    annotation_id: AnnotationId
    image_id: ImageId
    segmentation: Union[np.ndarray, CompressedRLE]
    area: float
    iscrowd: bool
    bbox: Bbox
    category_id: int

    @classmethod
    def compress_rle(
        cls,
        segmentation: Union[List[List[float]], UncompressedRLE],
        iscrowd: bool,
        height: int,
        width: int,
    ) -> CompressedRLE:
        if iscrowd:
            rle = cocomask.frPyObjects(segmentation, h=height, w=width)
        else:
            rles = cocomask.frPyObjects(segmentation, h=height, w=width)
            rle = cocomask.merge(rles)  # type: ignore

        return rle  # type: ignore

    @classmethod
    def rle_segmentation_to_binary_mask(
        cls, segmentation, iscrowd: bool, height: int, width: int
    ) -> np.ndarray:
        rle = cls.compress_rle(
            segmentation=segmentation, iscrowd=iscrowd, height=height, width=width
        )
        return cocomask.decode(rle)  # type: ignore

    @classmethod
    def rle_segmentation_to_mask(
        cls,
        segmentation: Union[List[List[float]], UncompressedRLE],
        iscrowd: bool,
        height: int,
        width: int,
    ) -> np.ndarray:
        binary_mask = cls.rle_segmentation_to_binary_mask(
            segmentation=segmentation, iscrowd=iscrowd, height=height, width=width
        )
        return binary_mask * 255

    @classmethod
    def from_dict(
        cls,
        json_dict: JsonDict,
        images: Dict[ImageId, ImageData],
        decode_rle: bool,
    ) -> "AnnotationData":
        segmentation = json_dict["segmentation"]
        image_id = json_dict["image_id"]
        image_data = images[image_id]
        iscrowd = bool(json_dict["iscrowd"])

        segmentation_mask = (
            cls.rle_segmentation_to_mask(
                segmentation=segmentation,
                iscrowd=iscrowd,
                height=image_data.height,
                width=image_data.width,
            )
            if decode_rle
            else cls.compress_rle(
                segmentation=segmentation,
                iscrowd=iscrowd,
                height=image_data.height,
                width=image_data.width,
            )
        )
        return cls(
            annotation_id=json_dict["id"],
            image_id=image_id,
            segmentation=segmentation_mask,  # type: ignore
            area=json_dict["area"],
            iscrowd=iscrowd,
            bbox=json_dict["bbox"],
            category_id=json_dict["category_id"],
        )


def load_json(json_path: pathlib.Path) -> JsonDict:
    logger.info(f"Load from {json_path}")
    with json_path.open("r") as rf:
        json_dict = json.load(rf)
    return json_dict


def load_image(image_path: pathlib.Path) -> PilImage:
    return Image.open(image_path)


def load_categories_data(
    category_dicts: List[JsonDict],
    tqdm_desc: str = "Load categories",
) -> Dict[CategoryId, CategoryData]:
    categories = {}
    for category_dict in tqdm(category_dicts, desc=tqdm_desc):
        category_data = CategoryData.from_dict(category_dict)
        categories[category_data.category_id] = category_data
    return categories


def load_images_data(
    image_dicts: List[JsonDict],
    tqdm_desc="Load images",
) -> Dict[ImageId, ImageData]:
    images = {}
    for image_dict in tqdm(image_dicts, desc=tqdm_desc):
        image_data = ImageData.from_dict(image_dict)
        images[image_data.image_id] = image_data
    return images


def load_annotation_data(
    label_dicts: List[JsonDict],
    images: Dict[ImageId, ImageData],
    decode_rle: bool,
    tqdm_desc: str = "Load label data",
) -> Dict[ImageId, List[AnnotationData]]:
    labels = defaultdict(list)
    label_dicts = sorted(label_dicts, key=lambda d: d["image_id"])

    for label_dict in tqdm(label_dicts, desc=tqdm_desc):
        label_data = AnnotationData.from_dict(
            label_dict, images=images, decode_rle=decode_rle
        )
        labels[label_data.image_id].append(label_data)
    return labels


def generate_train_val_examples(
    annotations: Dict[ImageId, List[AnnotationData]],
    image_dir: pathlib.Path,
    images: Dict[ImageId, ImageData],
    categories: Dict[CategoryId, CategoryData],
):
    for idx, image_id in enumerate(images.keys()):
        image_data = images[image_id]
        image_anns = annotations[image_id]

        if len(image_anns) < 1:
            logger.warning(f"No annotation found for image id: {image_id}.")
            continue

        image = load_image(image_path=image_dir / image_data.file_name)
        example = asdict(image_data)
        example["image"] = image

        example["annotations"] = []
        for ann in image_anns:
            ann_dict = asdict(ann)
            category = categories[ann.category_id]
            ann_dict["category"] = asdict(category)
            example["annotations"].append(ann_dict)

        yield idx, example


def generate_test_examples(image_dir: pathlib.Path):
    image_paths = [f for f in image_dir.iterdir() if f.suffix == ".jpg"]
    image_paths = sorted(image_paths)

    for idx, image_path in enumerate(image_paths):
        image = load_image(image_path=image_path)
        image_width, image_height = image.size
        image_data = ImageData(
            image_id=idx,
            file_name=image_path.name,
            width=image_width,
            height=image_height,
        )
        example = asdict(image_data)
        example["image"] = image
        example["annotations"] = []
        yield idx, example


@dataclass
class PubLayNetConfig(ds.BuilderConfig):
    decode_rle: bool = False


class PubLayNetDataset(ds.GeneratorBasedBuilder):
    VERSION = ds.Version("1.0.0")
    BUILDER_CONFIG_CLASS = PubLayNetConfig
    BUILDER_CONFIGS = [
        PubLayNetConfig(
            version=VERSION,
            description="PubLayNet is a dataset for document layout analysis.",
        )
    ]

    def _info(self) -> ds.DatasetInfo:
        segmentation_feature = (
            ds.Image()
            if self.config.decode_rle
            else {
                "counts": ds.Value("binary"),
                "size": ds.Sequence(ds.Value("int32")),
            }
        )
        features = ds.Features(
            {
                "image_id": ds.Value("int32"),
                "file_name": ds.Value("string"),
                "width": ds.Value("int32"),
                "height": ds.Value("int32"),
                "image": ds.Image(),
                "annotations": ds.Sequence(
                    {
                        "annotation_id": ds.Value("int32"),
                        "area": ds.Value("float32"),
                        "bbox": ds.Sequence(ds.Value("float32"), length=4),
                        "category": {
                            "category_id": ds.Value("int32"),
                            "name": ds.ClassLabel(
                                num_classes=5,
                                names=["text", "title", "list", "table", "figure"],
                            ),
                            "supercategory": ds.Value("string"),
                        },
                        "category_id": ds.Value("int32"),
                        "image_id": ds.Value("int32"),
                        "iscrowd": ds.Value("bool"),
                        "segmentation": segmentation_feature,
                    }
                ),
            }
        )
        return ds.DatasetInfo(
            description=_DESCRIPTION,
            citation=_CITATION,
            homepage=_HOMEPAGE,
            license=_LICENSE,
            features=features,
        )

    def _split_generators(self, dl_manager: ds.DownloadManager):
        base_dir = dl_manager.download_and_extract(_URL)
        publaynet_dir = pathlib.Path(base_dir) / "publaynet"

        return [
            ds.SplitGenerator(
                name=ds.Split.TRAIN,
                gen_kwargs={
                    "image_dir": publaynet_dir / "train",
                    "label_path": publaynet_dir / "train.json",
                },
            ),
            ds.SplitGenerator(
                name=ds.Split.VALIDATION,
                gen_kwargs={
                    "image_dir": publaynet_dir / "val",
                    "label_path": publaynet_dir / "val.json",
                },
            ),
            ds.SplitGenerator(
                name=ds.Split.TEST,
                gen_kwargs={
                    "image_dir": publaynet_dir / "test",
                },
            ),
        ]

    def _generate_train_val_examples(
        self, image_dir: pathlib.Path, label_path: pathlib.Path
    ):
        label_json = load_json(json_path=label_path)

        images = load_images_data(image_dicts=label_json["images"])
        categories = load_categories_data(category_dicts=label_json["categories"])

        annotations = load_annotation_data(
            label_dicts=label_json["annotations"],
            images=images,
            decode_rle=self.config.decode_rle,
        )
        yield from generate_train_val_examples(
            annotations=annotations,
            image_dir=image_dir,
            images=images,
            categories=categories,
        )

    def _generate_test_examples(self, image_dir: pathlib.Path):
        yield from generate_test_examples(image_dir=image_dir)

    def _generate_examples(
        self, image_dir: pathlib.Path, label_path: Optional[pathlib.Path] = None
    ):
        if label_path is not None:
            yield from self._generate_train_val_examples(
                image_dir=image_dir,
                label_path=label_path,
            )
        else:
            yield from self._generate_test_examples(
                image_dir=image_dir,
            )