"""
Taken and adapated from Alan Cooney's
https://github.com/ai-safety-foundation/sparse_autoencoder/tree/main/sparse_autoencoder.
"""

import subprocess
from collections.abc import Mapping, Sequence
from dataclasses import dataclass
from typing import TypedDict

from datasets import (
    Dataset,
    DatasetDict,
    VerificationMode,
    load_dataset,
)
from huggingface_hub import HfApi
from jaxtyping import Int
from pydantic import PositiveInt, validate_call
from torch import Tensor
from transformers import AutoTokenizer, PreTrainedTokenizerBase


class GenericTextDataBatch(TypedDict):
    """Generic Text Dataset Batch.

    Assumes the dataset provides a 'text' field with a list of strings.
    """

    text: list[str]
    meta: list[dict[str, dict[str, str]]]  # Optional, depending on the dataset structure.


TokenizedPrompt = list[int]
"""A tokenized prompt."""


class TokenizedPrompts(TypedDict):
    """Tokenized prompts."""

    input_ids: list[TokenizedPrompt]


class TorchTokenizedPrompts(TypedDict):
    """Tokenized prompts prepared for PyTorch."""

    input_ids: Int[Tensor, "batch pos vocab"]


class TextDataset:
    """Generic Text Dataset for any text-based dataset from Hugging Face."""

    tokenizer: PreTrainedTokenizerBase

    def preprocess(
        self,
        source_batch: GenericTextDataBatch,
        *,
        context_size: int,
    ) -> TokenizedPrompts:
        """Preprocess a batch of prompts.

        Tokenizes a batch of text data and packs into context_size samples. An eos token is added
        to the end of each document after tokenization.

        Args:
            source_batch: A batch of source data, including 'text' with a list of strings.
            context_size: Context size for tokenized prompts.

        Returns:
            Tokenized prompts.
        """
        prompts: list[str] = source_batch["text"]

        tokenized_prompts = self.tokenizer(prompts, truncation=False, padding=False)

        all_tokens = []
        for document_tokens in tokenized_prompts[self._dataset_column_name]:  # type: ignore
            all_tokens.extend(document_tokens + [self.tokenizer.eos_token_id])
        # Ignore incomplete chunks
        chunks = [
            all_tokens[i : i + context_size]
            for i in range(0, len(all_tokens), context_size)
            if len(all_tokens[i : i + context_size]) == context_size
        ]

        return {"input_ids": chunks}

    @validate_call(config={"arbitrary_types_allowed": True})
    def __init__(
        self,
        dataset_path: str,
        tokenizer: PreTrainedTokenizerBase,
        context_size: PositiveInt = 256,
        load_revision: str = "main",
        dataset_dir: str | None = None,
        dataset_files: str | Sequence[str] | Mapping[str, str | Sequence[str]] | None = None,
        dataset_split: str | None = None,
        dataset_column_name: str = "input_ids",
        n_processes_preprocessing: PositiveInt | None = None,
        preprocess_batch_size: PositiveInt = 1000,
    ):
        """Initialize a generic text dataset from Hugging Face.

        Args:
            dataset_path: Path to the dataset on Hugging Face (e.g. `'monology/pile-uncopyright'`).
            tokenizer: Tokenizer to process text data.
            context_size: The context size to use when returning a list of tokenized prompts.
                *Towards Monosemanticity: Decomposing Language Models With Dictionary Learning* used
                a context size of 250.
            load_revision: The commit hash or branch name to download from the source dataset.
            dataset_dir: Defining the `data_dir` of the dataset configuration.
            dataset_files: Path(s) to source data file(s).
            dataset_split: Dataset split (e.g., 'train'). If None, process all splits.
            dataset_column_name: The column name for the prompts.
            n_processes_preprocessing: Number of processes to use for preprocessing.
            preprocess_batch_size: Batch size for preprocessing (tokenizing prompts).
        """
        self.tokenizer = tokenizer

        self.context_size = context_size
        self._dataset_column_name = dataset_column_name

        # Load the dataset
        dataset = load_dataset(
            dataset_path,
            revision=load_revision,
            streaming=False,  # We need to pre-download the dataset to upload it to the hub.
            split=dataset_split,
            data_dir=dataset_dir,
            data_files=dataset_files,
            verification_mode=VerificationMode.NO_CHECKS,  # As it fails when data_files is set
        )
        # If split is not None, will return a Dataset instance. Convert to DatasetDict.
        if isinstance(dataset, Dataset):
            assert dataset_split is not None
            dataset = DatasetDict({dataset_split: dataset})
        assert isinstance(dataset, DatasetDict)

        for split in dataset:
            print(f"Processing split: {split}")
            # Setup preprocessing (we remove all columns except for input ids)
            remove_columns: list[str] = list(next(iter(dataset[split])).keys())  # type: ignore
            if "input_ids" in remove_columns:
                remove_columns.remove("input_ids")

            # Tokenize and chunk the prompts
            mapped_dataset = dataset[split].map(
                self.preprocess,
                batched=True,
                batch_size=preprocess_batch_size,
                fn_kwargs={"context_size": context_size},
                remove_columns=remove_columns,
                num_proc=n_processes_preprocessing,
            )
            dataset[split] = mapped_dataset.shuffle()

        self.dataset = dataset

    @validate_call
    def push_to_hugging_face_hub(
        self,
        repo_id: str,
        commit_message: str = "Upload preprocessed dataset using sparse_autoencoder.",
        max_shard_size: str = "500MB",
        revision: str = "main",
        *,
        private: bool = False,
    ) -> None:
        """Share preprocessed dataset to Hugging Face hub.

        Motivation:
            Pre-processing a dataset can be time-consuming, so it is useful to be able to share the
            pre-processed dataset with others. This function allows you to do that by pushing the
            pre-processed dataset to the Hugging Face hub.

        Warning:
            You must be logged into HuggingFace (e.g with `huggingface-cli login` from the terminal)
            to use this.

        Warning:
            This will only work if the dataset is not streamed (i.e. if `pre_download=True` when
            initializing the dataset).

        Args:
            repo_id: Hugging Face repo ID to save the dataset to (e.g. `username/dataset_name`).
            commit_message: Commit message.
            max_shard_size: Maximum shard size (e.g. `'500MB'`).
            revision: Branch to push to.
            private: Whether to save the dataset privately.
        """
        self.dataset.push_to_hub(
            repo_id=repo_id,
            commit_message=commit_message,
            max_shard_size=max_shard_size,
            private=private,
            revision=revision,
        )


@dataclass
class DatasetToPreprocess:
    """Dataset to preprocess info."""

    source_path: str
    """Source path from HF (e.g. `roneneldan/TinyStories`)."""

    tokenizer_name: str
    """HF tokenizer name (e.g. `gpt2`)."""

    load_revision: str = "main"
    """Commit hash or branch name to download from the source dataset."""

    data_dir: str | None = None
    """Data directory to download from the source dataset."""

    data_files: list[str] | None = None
    """Data files to download from the source dataset."""

    hugging_face_username: str = "apollo-research"
    """HF username for the upload."""

    private: bool = False
    """Whether the HF dataset should be private or public."""

    context_size: int = 2048
    """Number of tokens in a single sample. gpt2 uses 1024, pythia uses 2048."""

    split: str | None = None
    """Dataset split to download from the source dataset. If None, process all splits."""

    @property
    def source_alias(self) -> str:
        """Create a source alias for the destination dataset name.

        Returns:
            The modified source path as source alias.
        """
        return self.source_path.replace("/", "-")

    @property
    def tokenizer_alias(self) -> str:
        """Create a tokenizer alias for the destination dataset name.

        Returns:
            The modified tokenizer name as tokenizer alias.
        """
        return self.tokenizer_name.replace("/", "-")

    @property
    def destination_repo_name(self) -> str:
        """Destination repo name.

        Returns:
            The destination repo name.
        """
        split_str = f"{self.split}-" if self.split else ""
        return f"{self.source_alias}-{split_str}tokenizer-{self.tokenizer_alias}"

    @property
    def destination_repo_id(self) -> str:
        """Destination repo ID.

        Returns:
            The destination repo ID.
        """
        return f"{self.hugging_face_username}/{self.destination_repo_name}"


def upload_datasets(datasets_to_preprocess: list[DatasetToPreprocess]) -> None:
    """Upload datasets to HF.

    Warning:
        Assumes you have already created the corresponding repos on HF.

    Args:
        datasets_to_preprocess: List of datasets to preprocess.

    Raises:
        ValueError: If the repo doesn't exist.
    """
    repositories_updating = [dataset.destination_repo_id for dataset in datasets_to_preprocess]
    print("Updating repositories:\n" "\n".join(repositories_updating))

    for dataset in datasets_to_preprocess:
        print("Processing dataset: ", dataset.source_path)

        # Preprocess
        tokenizer = AutoTokenizer.from_pretrained(dataset.tokenizer_name)
        text_dataset = TextDataset(
            dataset_path=dataset.source_path,
            tokenizer=tokenizer,
            dataset_files=dataset.data_files,
            dataset_dir=dataset.data_dir,
            dataset_split=dataset.split,
            context_size=dataset.context_size,
            load_revision=dataset.load_revision,
        )
        # size_in_bytes and info gives info about the whole dataset regardless of the split index,
        # so we just get the first split.
        split = next(iter(text_dataset.dataset))
        print("Dataset info:")
        print(f"Size: {text_dataset.dataset[split].size_in_bytes / 1e9:.2f} GB")  # type: ignore
        print("Info: ", text_dataset.dataset[split].info)

        # Upload
        text_dataset.push_to_hugging_face_hub(
            repo_id=dataset.destination_repo_id, private=dataset.private
        )
        # Also upload the current file to the repo for reproducibility and transparency
        api = HfApi()
        api.upload_file(
            path_or_fileobj=__file__,
            path_in_repo="upload_script.py",
            repo_id=dataset.destination_repo_id,
            repo_type="dataset",
            commit_message="Add upload script",
        )


if __name__ == "__main__":
    # Check that the user is signed in to huggingface-cli
    try:
        result = subprocess.run(
            ["huggingface-cli", "whoami"], check=True, capture_output=True, text=True
        )
        if "Not logged in" in result.stdout:
            print("Please sign in to huggingface-cli using `huggingface-cli login`.")
            raise Exception("You are not logged in to huggingface-cli.")
    except subprocess.CalledProcessError:
        print("An error occurred while checking the login status.")
        raise

    datasets: list[DatasetToPreprocess] = [
        DatasetToPreprocess(
            source_path="roneneldan/TinyStories",
            # Paper says gpt-neo tokenizer, and e.g. EleutherAI/gpt-neo-125M uses the same tokenizer
            # as gpt2. They also suggest using gpt2 in (https://github.com/EleutherAI/gpt-neo).
            tokenizer_name="gpt2",
            hugging_face_username="apollo-research",
            context_size=512,
        ),
        DatasetToPreprocess(
            source_path="Skylion007/openwebtext",
            tokenizer_name="gpt2",
            hugging_face_username="apollo-research",
            context_size=1024,
        ),
        DatasetToPreprocess(
            source_path="Skylion007/openwebtext",
            tokenizer_name="EleutherAI/gpt-neox-20b",
            hugging_face_username="apollo-research",
            context_size=2048,
        ),
        DatasetToPreprocess(
            source_path="monology/pile-uncopyrighted",
            tokenizer_name="gpt2",
            hugging_face_username="apollo-research",
            context_size=1024,
            # Get just the first few (each file is 11GB so this should be enough for a large dataset)
            data_files=[
                "train/00.jsonl.zst",
                "train/01.jsonl.zst",
                "train/02.jsonl.zst",
                "train/03.jsonl.zst",
                "train/04.jsonl.zst",
            ],
        ),
        DatasetToPreprocess(
            source_path="monology/pile-uncopyrighted",
            tokenizer_name="EleutherAI/gpt-neox-20b",
            hugging_face_username="apollo-research",
            private=False,
            context_size=2048,
            data_files=[
                "train/00.jsonl.zst",
                "train/01.jsonl.zst",
                "train/02.jsonl.zst",
                "train/03.jsonl.zst",
                "train/04.jsonl.zst",
            ],
        ),
    ]

    upload_datasets(datasets)