import torchdata.datapipes as dp
import json
from PIL import Image
import functools
import numpy as np
import torch
import pickle
import random
import os
from braceexpand import braceexpand
from torch.utils.data.datapipes.iter.sharding import SHARDING_PRIORITIES
from torch.utils.data.dataloader import default_collate
import base64
import io
import tarfile
from torchdata.datapipes.iter import TarArchiveLoader
from typing import cast, IO, Iterable, Iterator, Optional, Tuple, Dict
from torchdata.datapipes import functional_datapipe
from io import BufferedIOBase
from torchdata.datapipes.utils import StreamWrapper
from torchdata.datapipes.utils.common import validate_pathname_binary_tuple
import warnings
from torchdata.datapipes.iter import IterDataPipe
import hydra
from omegaconf import OmegaConf
import pyrootutils

pyrootutils.setup_root(__file__, indicator='.project-root', pythonpath=True)

BOI_TOKEN = '<img>'
EOI_TOKEN = '</img>'
IMG_TOKEN = '<img_{:05d}>'


@functional_datapipe("load_from_tar_wo_exception")
class TarArchiveLoaderWoException(TarArchiveLoader):
    def __iter__(self) -> Iterator[Tuple[str, BufferedIOBase]]:
        for data in self.datapipe:
            validate_pathname_binary_tuple(data)
            pathname, data_stream = data
            try:
                if isinstance(data_stream, StreamWrapper) and isinstance(data_stream.file_obj, tarfile.TarFile):
                    tar = data_stream.file_obj
                else:
                    reading_mode = (self.mode if hasattr(data_stream, "seekable") and data_stream.seekable() else
                                    self.mode.replace(":", "|"))
                    # typing.cast is used here to silence mypy's type checker
                    tar = tarfile.open(fileobj=cast(
                        Optional[IO[bytes]], data_stream), mode=reading_mode)
                for tarinfo in tar:
                    if not tarinfo.isfile():
                        continue
                    extracted_fobj = tar.extractfile(tarinfo)
                    if extracted_fobj is None:
                        warnings.warn(
                            f"failed to extract file {tarinfo.name} from source tarfile {pathname}")
                        raise tarfile.ExtractError
                    inner_pathname = os.path.normpath(
                        os.path.join(pathname, tarinfo.name))
                    # type: ignore[misc]
                    yield inner_pathname, StreamWrapper(extracted_fobj, data_stream, name=inner_pathname)
            except Exception as e:
                warnings.warn(
                    f"Unable to extract files from corrupted tarfile stream {pathname} due to: {e}, abort!")
                # raise e
            finally:
                if isinstance(data_stream, StreamWrapper):
                    data_stream.autoclose()


def decode_obelisc_data_for_llm(item, tokenizer=None, max_length=512, reverse_ratio=0.5, max_images=None):
    key, value = item

    sample = {}
    if key.endswith(".pkl"):
        try:
            value = pickle.load(value)
        except Exception as e:
            print(f'Error occured when load pkl: {e}')
            return key, sample

        image_list = value['image_ids']
        text_list = value['texts']
        metadata = value['metadata']

        reverse_flag = np.random.uniform(0, 1) < reverse_ratio
        if reverse_flag:
            idx = 0
            while idx < len(image_list) - 1:
                if image_list[idx] is not None:
                    image_list[idx], image_list[idx +
                                                1] = image_list[idx + 1], image_list[idx]
                    text_list[idx], text_list[idx +
                                              1] = text_list[idx + 1], text_list[idx]
                    idx += 2
                else:
                    idx += 1

        unified_tokens = tokenizer.bos_token
        cur_images = 0
        for image_id, text in zip(image_list, text_list):
            if (image_id is None) + (text is None) != 1:
                print('Incorrect data format, skip.')
                return key, {}
            if image_id is not None:
                if max_images is not None and cur_images >= max_images:
                    break
                image_tokens = BOI_TOKEN + \
                    ''.join([IMG_TOKEN.format(int(item))
                            for item in image_id]) + EOI_TOKEN
                unified_tokens += image_tokens
                cur_images += 1
            else:
                unified_tokens += text
                if max_images is not None and cur_images >= max_images:
                    break
        unified_tokens += tokenizer.eos_token

        tokenized = tokenizer(unified_tokens,
                              max_length=max_length,
                              add_special_tokens=False,
                              truncation=True,
                              padding='max_length',
                              return_tensors='pt')

        input_ids = tokenized['input_ids'][0]
        attention_mask = tokenized['attention_mask'][0]
        labels = torch.clone(input_ids)
        labels[labels == tokenizer.pad_token_id] = -100
        filter_flag = True

        return key, {
            'input_ids': input_ids,
            'attention_mask': attention_mask,
            'labels': labels,
            'filter_flag': filter_flag,
        }
    else:
        return key, None


def unwarp_data(item):
    unwarpped = {}
    for key, value in item.items():
        if isinstance(value, dict):
            unwarpped.update(value)
        elif value is not None:
            unwarpped[key] = value
    if 'metadata' not in unwarpped:
        unwarpped['metadata'] = '{}'
    if '__key__' in unwarpped:
        unwarpped['__key__'] = unwarpped['__key__'].split('/')[-1]
    return unwarpped


def filter_data_for_llm(item):
    if 'input_ids' in item and item.get('filter_flag', True):
        return True
    else:
        print('A sample has been filtered out.')
        return False


def build_obelisc_datapipes_for_llm(data_dir,
                                    tokenizer=None,
                                    max_length=512,
                                    reverse_ratio=0.5,
                                    max_images=None,
                                    recursive=True,
                                    batch_size=None,
                                    cycle_count=None):
    """
    datapipe of image interleaved dataset (such as mmc4...) with webdataset format
    """

    decode_partial = functools.partial(decode_obelisc_data_for_llm,
                                       tokenizer=tokenizer,
                                       max_length=max_length,
                                       reverse_ratio=reverse_ratio,
                                       max_images=max_images)

    if isinstance(data_dir, str):
        data_dir = list(braceexpand(data_dir))
    # datapipe = dp.iter.FileLister(root=data_dir, masks='mmc4-0-000004.tar', recursive=True)
    datapipe = dp.iter.FileLister(
        root=data_dir, masks='*.tar', recursive=recursive)
    datapipe = datapipe.cycle(count=cycle_count)
    datapipe = datapipe.shuffle()
    datapipe = datapipe.sharding_filter()
    datapipe = datapipe.open_files(mode='b')
    datapipe = datapipe.load_from_tar_wo_exception()
    datapipe = datapipe.map(decode_partial)
    datapipe = datapipe.webdataset()
    datapipe = datapipe.map(unwarp_data)
    datapipe = datapipe.filter(filter_data_for_llm)
    datapipe = datapipe.shuffle(buffer_size=4096)
    if batch_size is not None:
        datapipe = datapipe.batch(batch_size)
        datapipe = datapipe.collate()
    return datapipe


if __name__ == '__main__':
    from torchdata.dataloader2 import DataLoader2, MultiProcessingReadingService, DistributedReadingService, SequentialReadingService
    data_dir = './obelisc'
    seed_tokenizer_cfg_path = ''
    dataloader_num_workers = 2

    seed_tokenizer_cfg = OmegaConf.load(seed_tokenizer_cfg_path)
    seed_tokenizer = hydra.utils.instantiate(seed_tokenizer_cfg)

    dataset = build_obelisc_datapipes_for_llm(
        data_dir=data_dir, tokenizer=seed_tokenizer, max_length=1024, cycle_count=1)

    mp_rs = MultiProcessingReadingService(
        num_workers=dataloader_num_workers)
    dist_rs = DistributedReadingService()
    rs = SequentialReadingService(dist_rs, mp_rs)

    dataloader = DataLoader2(dataset, reading_service=rs)