from __future__ import annotations

import json
import warnings
from typing import Optional, Union, overload

import torch.distributed as dist

from arpeggio.dataloader import (
    ArpeggioBaseDataloader,
    ArpeggioIterableDataloader,
    ArpeggioMapStyleDataloader,
    DataloaderArgs,
)
from arpeggio.dataset import ArpeggioTinyIterableDataset, ArpeggioIterableDataset, ArpeggioMapStyleDataset, ArpeggioMultiSourceIterableDataset
from arpeggio.meta import DataSourceMeta, read_dataset_meta_paths
from arpeggio.sampler import BatchSampler, ContinuousBatchSampler
from arpeggio.tuners import load_transform
from arpeggio.tuners.base import TransformBase
from arpeggio.utils.io_utils import glob_files, read_file


Filepaths = list[str]
RankToFilepaths = list[list[str]]


# Create dataloader with filepaths
@overload
def create_dataloader(
    *,
    filepaths: Union[list[str], str],
    args: Optional[DataloaderArgs] = None,
    model_path: Optional[str] = None,
    model_type: Optional[str] = None,
    transform: Optional[TransformBase] = None,
    dp_group: Optional[dist.ProcessGroup] = None,
    dataset_meta_paths: Union[list[str], str, None] = None,
) -> ArpeggioBaseDataloader: ...


# Create dataloader with patterns
@overload
def create_dataloader(
    *,
    patterns: Union[list[str], str],
    args: Optional[DataloaderArgs] = None,
    model_path: Optional[str] = None,
    model_type: Optional[str] = None,
    transform: Optional[TransformBase] = None,
    dp_group: Optional[dist.ProcessGroup] = None,
    dataset_meta_paths: Union[list[str], str, None] = None,
) -> ArpeggioBaseDataloader: ...


# Create dataloader with rank_to_filepaths
@overload
def create_dataloader(
    *,
    rank_to_filepaths: RankToFilepaths,
    args: Optional[DataloaderArgs] = None,
    model_path: Optional[str] = None,
    model_type: Optional[str] = None,
    transform: Optional[TransformBase] = None,
    dp_group: Optional[dist.ProcessGroup] = None,
) -> ArpeggioBaseDataloader: ...


# Create dataloader with data_source_metas
@overload
def create_dataloader(
    *,
    data_source_metas: Union[list[DataSourceMeta], list[str], DataSourceMeta, str, None] = None,
    args: Optional[DataloaderArgs] = None,
    model_path: Optional[str] = None,
    model_type: Optional[str] = None,
    transform: Optional[TransformBase] = None,
    dp_group: Optional[dist.ProcessGroup] = None,
) -> ArpeggioBaseDataloader: ...


def create_dataloader(
    *,
    args: Optional[DataloaderArgs] = None,
    model_path: Optional[str] = None,
    model_type: Optional[str] = None,
    transform: Optional[TransformBase] = None,
    dp_group: Optional[dist.ProcessGroup] = None,
    filepaths: Union[list[str], str, None] = None,
    patterns: Union[list[str], str, None] = None,
    rank_to_filepaths: Optional[RankToFilepaths] = None,
    data_source_metas: Union[list[DataSourceMeta], list[str], DataSourceMeta, str, None] = None,
    dataset_meta_paths: Union[list[str], str, None] = None,
    **kwargs,
) -> ArpeggioBaseDataloader:
    if len(kwargs) > 0:
        warnings.warn(f"create_dataloader unused kwargs: {list(kwargs.keys())}", UserWarning)

    # Initialize args if None
    if args is None:
        args = DataloaderArgs()

    dp_rank, dp_size = 0, 1
    if dp_group is not None:
        dp_rank, dp_size = dp_group.rank(), dp_group.size()
    total_workers = args.num_workers * dp_size

    # Resolve data source
    _ensure_only_one_given(
        filepaths=filepaths,
        patterns=patterns,
        rank_to_filepaths=rank_to_filepaths,
        data_source_metas=data_source_metas,
    )

    if filepaths is not None:
        if isinstance(filepaths, str):
            filepaths = [filepaths]
        assert len(filepaths) > 0

    elif patterns is not None:
        filepaths = _patterns_to_filepaths(patterns)
        assert len(filepaths) > 0

    elif rank_to_filepaths is not None:
        if len(rank_to_filepaths) != total_workers:
            raise ValueError(
                "rank_to_filepaths should be of size dp_size * num_workers = "
                f"{dp_size} * {args.num_workers} = {total_workers}"
            )

    else:
        assert data_source_metas is not None
        if isinstance(data_source_metas, (str, dict)):
            data_source_metas = [data_source_metas]
        assert len(data_source_metas) > 0
        if isinstance(data_source_metas[0], str):
            # Data sources are located in files, have to read them
            data_source_metas = [_read_json_from_file(filepath) for filepath in data_source_metas]
        if not args.iterable:
            warnings.warn(
                "multi-source dataset only supports iterable, iterable mode automatically used",
                UserWarning,
            )
            args.iterable = True

    # Rsolve transform
    transform = _resolve_transform(
        model_path=model_path,
        model_type=model_type,
        transform=transform,
    )

    # Handle map-style
    if not args.iterable:
        assert filepaths is not None, "filepaths / patterns necessary for map style dataset"

        if args.allow_skip_files:
            warnings.warn("allow_skip_files not implemented for map-style datasets")
        if args.max_seq_len is not None:
            warnings.warn("max_seq_len not implemented for map-style datasets")
        if args.max_micro_steps is not None:
            warnings.warn("max_micro_steps not implemented for map-style datasets")

        dataset = ArpeggioMapStyleDataset(
            filepaths=filepaths,
            transform=transform,
            pad_to_multiple_of=args.pad_to_multiple_of,
            dp_rank=dp_rank,
            dp_size=dp_size,
        )

        if args.is_continuous_batch:
            if dataset_meta_paths is None:
                raise ValueError("dataset_meta_paths is required for map-style continous batching")

            # Extract seq lens from dataset meta
            filepath_to_meta = read_dataset_meta_paths(dataset_meta_paths)
            seq_lens = []
            for filepath in dataset.filepaths:
                meta = filepath_to_meta[filepath]
                seq_lens.extend(meta["seq_len"])

            # Make batch sampler
            batch_sampler = ContinuousBatchSampler(
                seq_lens=seq_lens,
                max_tokens_per_batch=args.max_tokens_per_batch,
                max_samples_per_batch=args.max_samples_per_batch,
                shuffle=args.shuffle,
                seed=args.seed,
                num_epoch=args.num_epoch,
                generate_infinitely=args.generate_infinitely,
                dp_group=dp_group,
            )

        else:
            # Make batch sampler
            batch_sampler = BatchSampler(
                dataset_size=len(dataset),
                batch_size=args.micro_batch_size,
                shuffle=args.shuffle,
                seed=args.seed,
                num_epoch=args.num_epoch,
                generate_infinitely=args.generate_infinitely,
                dp_group=dp_group,
                max_tokens_per_batch=args.max_tokens_per_batch,
                max_samples_per_batch=args.max_samples_per_batch,
            )

        return ArpeggioMapStyleDataloader(
            dataset=dataset,
            args=args,
            dp_group=dp_group,
            batch_sampler=batch_sampler,
        )

    iterable_dataset_kwargs = {
        "transform": transform,
        "max_seq_len": args.max_seq_len,
        "micro_batch_size": args.micro_batch_size,
        "is_continuous_batch": args.is_continuous_batch,
        "max_tokens_per_batch": args.max_tokens_per_batch,
        "max_samples_per_batch": args.max_samples_per_batch,
        "pad_to_multiple_of": args.pad_to_multiple_of,
        "shuffle": args.shuffle,
        "num_epoch": args.num_epoch,
        "max_micro_steps": args.max_micro_steps,
        "generate_infinitely": args.generate_infinitely,
        "allow_skip_files": args.allow_skip_files,
        "seed": args.seed,
        "dp_rank": dp_rank,
        "dp_size": dp_size,
    }

    if data_source_metas is not None:
        dataset = ArpeggioMultiSourceIterableDataset(
            data_source_metas=data_source_metas,
            num_workers=args.num_workers,
            est_continuous_batch_efficiency=args.est_continuous_batch_efficiency,
            **iterable_dataset_kwargs,
        )
    elif args.tiny_iterable:
        assert filepaths is not None, "filepaths / patterns necessary for tiny iterable dataset"
        dataset = ArpeggioTinyIterableDataset(
            filepaths=filepaths,
            **iterable_dataset_kwargs,
        )

    else:
        dataset = ArpeggioIterableDataset(
            filepaths=filepaths,
            rank_to_filepaths=rank_to_filepaths,
            **iterable_dataset_kwargs,
        )

    return ArpeggioIterableDataloader(
        dataset=dataset,
        args=args,
        dp_group=dp_group,
    )


def _ensure_only_one_given(**kwargs) -> bool:
    names = tuple(kwargs.keys())
    seen = 0
    for arg in kwargs.values():
        if arg is None:
            continue
        if seen > 0:
            raise ValueError(f"One of {names} must be provided and only one")
        seen += 1
    if seen == 0:
        raise ValueError(f"One of {names} must be provided and only one")


def _resolve_transform(
    model_path: Optional[str] = None,
    model_type: Optional[str] = None,
    transform: Optional[TransformBase] = None,
    **extra_kwargs,
) -> TransformBase:
    if transform is not None:
        if model_path is not None:
            raise ValueError("Either model_path or transform must be provided but not both.")
        return transform

    if model_path is None:
        raise ValueError("If transform isn't provided, model_path must be used.")
    return load_transform(model_path=model_path, model_type=model_type, **extra_kwargs)


def _patterns_to_filepaths(patterns: Union[list[str], str]):
    if isinstance(patterns, str):
        patterns = [patterns]

    filepaths = []
    for pattern in patterns:
        filepaths.extend(glob_files(pattern))
    filepaths = sorted(filepaths)
    return filepaths


def _read_json_from_file(filepath: str) -> object:
    return json.loads(read_file(filepath))