import os
import json
import datasets
import rasterio
from datetime import datetime
from tqdm import tqdm

class SSL4EOEUForest(datasets.GeneratorBasedBuilder):
    """
    SSL4EO-EU Forest Dataset Loader

    This loader supports both directory-based scanning and prebuilt index streaming via JSONL.
    It yields one sample at a time, making it compatible with Hugging Face's streaming mode.

    Each sample includes:
    - A list of image paths (one per timestamp)
    - A single mask path
    - Start and end timestamps for each image
    - Sentinel tile IDs
    - Bounding box metadata

    Bounding boxes are stored as a dictionary of arrays:
        {
            "minx": [...], "maxx": [...], "miny": [...], "maxy": [...]
        }

    This avoids redundancy and simplifies downstream parsing.
    """

    def _info(self):
        return datasets.DatasetInfo(
            description="SSL4EO-EU Forest dataset with grouped timestamps and bounding box metadata.",
            features=datasets.Features({
                "image_paths": datasets.Sequence(datasets.Value("string")),
                "mask_path": datasets.Value("string"),
                "start_timestamps": datasets.Sequence(datasets.Value("timestamp[ms]")),
                "end_timestamps": datasets.Sequence(datasets.Value("timestamp[ms]")),
                "sentinel_tile_ids": datasets.Sequence(datasets.Value("string")),
                "bboxes": datasets.Features({
                    "minx": datasets.Sequence(datasets.Value("float32")),
                    "maxx": datasets.Sequence(datasets.Value("float32")),
                    "miny": datasets.Sequence(datasets.Value("float32")),
                    "maxy": datasets.Sequence(datasets.Value("float32")),
                })
            }),
            citation="""@misc{ssl4eo_eu_forest,
  author = {Nassim Ait Ali Braham and Conrad M Albrecht},
  title = {SSL4EO-EU Forest Dataset},
  year = {2025},
  howpublished = {https://huggingface.co/datasets/dm4eo/ssl4eo-eu-forest},
  note = {Funded by the EvoLand project under EU Horizon Europe grant No. 101082130.}
}""",
            homepage="https://www.evo-land.eu",
            license="CC-BY-4.0",
        )

    def _split_generators(self, dl_manager):
        use_index = os.environ.get("HF_DATASET_USE_INDEX", "false").lower() == "true"
        use_local = os.environ.get("HF_DATASET_LOCAL", "false").lower() == "true"
        root = os.path.abspath(".") if use_local else dl_manager.download_and_extract(".")

        if use_index:
            index_path = os.path.join(root, "index.jsonl")
            return [datasets.SplitGenerator(name="all", gen_kwargs={"index_path": index_path})]
        else:
            images_dir = os.path.join(root, "images")
            masks_dir = os.path.join(root, "masks")
            return [datasets.SplitGenerator(name="all", gen_kwargs={
                "images_dir": images_dir,
                "masks_dir": masks_dir
            })]

    def _generate_examples(self, index_path=None, images_dir=None, masks_dir=None):
        if index_path:
            with open(index_path, "r") as f:
                for key, line in enumerate(f):
                    entry = json.loads(line)
                    entry["start_timestamps"] = [datetime.fromisoformat(ts) for ts in entry["start_timestamps"]]
                    entry["end_timestamps"] = [datetime.fromisoformat(ts) for ts in entry["end_timestamps"]]
                    yield key, entry
        else:
            sample_ids = sorted(os.listdir(images_dir))
            key = 0
            for sample_id in sample_ids:
                sample = self._parse_sample(sample_id, images_dir, masks_dir)
                if sample:
                    yield key, sample
                    key += 1

    @staticmethod
    def _parse_sample(sample_id, images_dir, masks_dir):
        """
        Parses a single sample directory and returns a dictionary with all metadata.

        Returns None if the sample is incomplete or malformed.
        """
        sample_path = os.path.join(images_dir, sample_id)
        if not os.path.isdir(sample_path):
            return None

        mask_path = os.path.join(masks_dir, sample_id, "mask.tif")
        if not os.path.exists(mask_path):
            return None

        image_paths, start_ts, end_ts, tile_ids = [], [], [], []
        minx_list, maxx_list, miny_list, maxy_list = [], [], [], []

        for ts in sorted(os.listdir(sample_path)):
            parts = ts.split("_")
            if len(parts) != 3:
                continue
            try:
                start = datetime.strptime(parts[0], "%Y%m%dT%H%M%S")
                end = datetime.strptime(parts[1], "%Y%m%dT%H%M%S")
            except ValueError:
                continue

            tile_id = parts[2]
            image_path = os.path.join(sample_path, ts, "all_bands.tif")
            if not os.path.exists(image_path):
                continue

            try:
                with rasterio.open(image_path) as src:
                    bounds = src.bounds
            except Exception:
                continue

            image_paths.append(image_path)
            start_ts.append(start)
            end_ts.append(end)
            tile_ids.append(tile_id)
            minx_list.append(bounds.left)
            maxx_list.append(bounds.right)
            miny_list.append(bounds.bottom)
            maxy_list.append(bounds.top)

        if not image_paths:
            return None

        return {
            "image_paths": image_paths,
            "mask_path": mask_path,
            "start_timestamps": start_ts,
            "end_timestamps": end_ts,
            "sentinel_tile_ids": tile_ids,
            "bboxes": {
                "minx": minx_list,
                "maxx": maxx_list,
                "miny": miny_list,
                "maxy": maxy_list
            }
        }

    @classmethod
    def generate_index(cls, dataset_dir, output_path="index.jsonl"):
        """
        Scans the dataset directory and writes a streaming-friendly index.jsonl file.

        Each line is a complete sample in JSON format.
        """
        images_dir = os.path.join(dataset_dir, "images")
        masks_dir = os.path.join(dataset_dir, "masks")
        sample_ids = sorted(os.listdir(images_dir))

        with open(output_path, "w") as f:
            for sample_id in tqdm(sample_ids, desc="Generating index", unit="sample"):
                sample = cls._parse_sample(sample_id, images_dir, masks_dir)
                if sample:
                    sample["start_timestamps"] = [ts.isoformat() for ts in sample["start_timestamps"]]
                    sample["end_timestamps"] = [ts.isoformat() for ts in sample["end_timestamps"]]
                    sample["sample_id"] = sample_id
                    f.write(json.dumps(sample) + "\n")

        print(f"✅ Index written to {output_path}")