# coding=utf-8
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""HuggingFace datasets implementation of the json tasks in the BIG-Bench Dataset.
For the programatic tasks, please use the BIG-Bench API on github.com/google/BIG-bench.
"""


from typing import Optional

import bigbench.api.util as bb_utils  # From: "bigbench @ https://storage.googleapis.com/public_research_data/bigbench/bigbench-0.0.1.tar.gz"
import bigbench.bbseqio.bigbench_bridge as bbb
from bigbench.api import json_task
from bigbench.bbseqio import bigbench_json_paths as bb_json_paths
from sentencepiece import sentencepiece_model_pb2  # noqa: this is also required by bigbench.api.util

import datasets


logger = datasets.logging.get_logger(__name__)

_CITATION = """\
@InProceedings{bigbench,
title = {Beyond the Imitation Game: Quantifying and extrapolating the
capabilities of language models},
author={BIG-Bench Collaboration
},
year={2022}
}
"""

_DESCRIPTION = """\
The Beyond the Imitation Game Benchmark (BIG-bench) is a collaborative benchmark intended to
probe large language models, and extrapolate their future capabilities.
"""

_HOMEPAGE = "https://github.com/google/BIG-bench"

_LICENSE = "Apache License 2.0"


def div_or_none(x, y):
    return x // y if x else x


def validate_task_name(task_name: str) -> None:
    """Check that the requested task name is a valid bigbench json task."""
    if task_name in bb_utils.get_all_json_task_names():
        return
    elif task_name in bb_utils.get_all_programmatic_task_names():
        raise ValueError(
            "BIG-Bench does not support programmatic tasks through HuggingFace datasets"
            f"Please see {_HOMEPAGE} for more information for how to interact with the programmatic tasks."
        )
    else:
        raise ValueError(
            f"Invalid task_name. Got task_name = {task_name}. Please choose one from:\n -- "
            + "\n -- ".join(bb_utils.get_all_json_task_names())
        )


def validate_subtask_name(task_name: str, subtask_name: str) -> None:
    """Check that the requested subtask name is a valid bigbench subtask."""
    subtasks = [name.split(":")[-1] for name in bb_utils.get_subtask_names_from_task(task_name)]
    if not subtasks:
        raise ValueError(f"Task {task_name} has no subtasks. Got subtask_name = {subtask_name}.")
    elif subtask_name not in subtasks:
        raise ValueError(
            f"Invalid subtask_name {subtask_name} for task {task_name}. Please choose one from:\n -- "
            + "\n -- ".join(subtasks)
        )


class BigBenchConfig(datasets.BuilderConfig):
    def __init__(
        self,
        name,
        subtask_name: Optional[str] = None,
        num_shots: int = 0,
        max_examples: Optional[int] = None,
        **kwargs,
    ):
        super().__init__(
            name=name,
            **kwargs,
        )
        """BIG-bench configuration.

        Args:
          name: BIG-bench task name.
          subtask_name: BIG-bench subtask name. Accepts both "task_name:subtask_name" and "subtask_name" formats.
          num_shots: Number of few-shot examples in input prompt. Default is zero.
          max_examples: Limit number of examples for each task. Default is including all examples.
        """
        self.task_name = name
        self.subtask_name = subtask_name
        self.num_shots = num_shots
        self.max_examples = max_examples


class Bigbench(datasets.GeneratorBasedBuilder):
    """The Beyond the Imitation Game Benchmark (BIG-bench) is a collaborative benchmark
    intended to probe large language models, and extrapolate their future capabilities."""

    VERSION = datasets.Version("1.0.0")

    BUILDER_CONFIG_CLASS = BigBenchConfig

    BUILDER_CONFIGS = [
        BigBenchConfig(name=name, version=datasets.Version("1.0.0")) for name in bb_utils.get_all_json_task_names()
    ]

    def _info(self):
        features = datasets.Features(
            {
                "idx": datasets.Value("int32"),
                "inputs": datasets.Value("string"),
                "targets": datasets.Sequence(datasets.Value("string")),
                "multiple_choice_targets": datasets.Sequence(datasets.Value("string")),
                "multiple_choice_scores": datasets.Sequence(datasets.Value("int32")),
            }
        )
        return datasets.DatasetInfo(
            # This is the description that will appear on the datasets page.
            description=_DESCRIPTION,
            # This defines the different columns of the dataset and their types
            features=features,  # Here we define them above because they are different between the two configurations
            # If there's a common (input, target) tuple from the features,
            # specify them here. They'll be used if as_supervised=True in
            # builder.as_dataset.
            supervised_keys=None,
            # Homepage of the dataset for documentation
            homepage=_HOMEPAGE,
            # License for the dataset if available
            license=_LICENSE,
            # Citation for the dataset
            citation=_CITATION,
        )

    def _split_generators(self, dl_manager):
        """Returns SplitGenerators."""
        return [
            datasets.SplitGenerator(
                name=datasets.splits.NamedSplit("default"),  # TODO(ajandreassen): Is there a way to call this 'all'?
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "split": "all",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.TRAIN,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "split": "train",
                },
            ),
            datasets.SplitGenerator(
                name=datasets.Split.VALIDATION,
                # These kwargs will be passed to _generate_examples
                gen_kwargs={
                    "split": "validation",
                },
            ),
        ]

    def _generate_examples(
        self,
        split,  # method parameters are unpacked from `gen_kwargs` as given in `_split_generators`
    ):
        validate_task_name(self.config.task_name)
        if self.config.subtask_name:
            # Subtasks are sometimes in bigbench written as task_name:subtask_name.
            # We want to remove the task_name from the subtask names:
            self.config.subtask_name = self.config.subtask_name.split(":")[-1]
            validate_subtask_name(self.config.task_name, self.config.subtask_name)

        """Yields examples as (key, example) tuples."""
        if split == "all":
            # not cutoff in number of examples for 'all' split
            MIN_VALIDATION_EXAMPLES = 0
        else:
            MIN_VALIDATION_EXAMPLES = 16

        try:
            task_path, json_util = bb_json_paths.get_task_path(self.config.task_name)

            has_subtasks = bb_json_paths.has_subtasks(self.config.task_name)
            if has_subtasks:
                subtask_names = bb_json_paths.get_subtask_names(self.config.task_name)
                num_subtasks = len(subtask_names)
                min_validation_examples_per_subtask = div_or_none(MIN_VALIDATION_EXAMPLES, num_subtasks)

            if not has_subtasks:
                ds_fn = bbb.get_dataset_fn(
                    task_name=self.config.task_name,
                    task_path=task_path,
                    subtask_name=None,
                    num_shots=self.config.num_shots,
                    bigbench_task_type=bbb.BigBenchTaskType.HUGGINGFACE,
                    max_examples=self.config.max_examples,
                    json_util=json_util,
                    min_validation_examples=MIN_VALIDATION_EXAMPLES,
                    format_fn=json_task.default_format_fn,
                )
                ds_list = [ds_fn(split)]
            elif self.config.subtask_name is not None:
                ds_fn = bbb.get_dataset_fn(
                    task_name=self.config.task_name,
                    task_path=task_path,
                    subtask_name=self.config.subtask_name,
                    num_shots=self.config.num_shots,
                    bigbench_task_type=bbb.BigBenchTaskType.HUGGINGFACE,
                    max_examples=self.config.max_examples,
                    json_util=json_util,
                    min_validation_examples=min_validation_examples_per_subtask,
                    format_fn=json_task.default_format_fn,
                )
                ds_list = [ds_fn(split)]
            else:
                # Create mixture of all subtasks
                ds_list = []
                for subtask_name in subtask_names:
                    subtask_name = subtask_name.split(":")[-1]
                    logger.info(f"Loading subtask {split} split", subtask_name)
                    ds_fn = bbb.get_dataset_fn(
                        task_name=self.config.task_name,
                        task_path=task_path,
                        subtask_name=subtask_name,
                        num_shots=self.config.num_shots,
                        bigbench_task_type=bbb.BigBenchTaskType.HUGGINGFACE,
                        max_examples=div_or_none(self.config.max_examples, num_subtasks),
                        json_util=json_util,
                        min_validation_examples=min_validation_examples_per_subtask,
                        format_fn=json_task.default_format_fn,
                    )
                    ds_list.append(ds_fn(split))
        except ValueError as value_error:
            # BIG-Bench requires at least 16 examples to use the train & validation splits,
            # while using 'all'/'default' does not have such a requirement.
            if "has too few examples" in value_error.args[0] and split != "all":
                logger.warning(
                    f"-- WARNING: skipping split {split} because it has too few examples. Please use 'default' split."
                )
                logger.warning(value_error)
                return
            raise value_error

        unique_key_counter = 0
        for ds in ds_list:
            for example in ds:
                unique_key_counter += 1
                yield unique_key_counter, {
                    "idx": example["idx"],
                    "inputs": example["inputs"].numpy().decode().strip(),
                    "targets": [target.numpy().decode().strip() for target in example["targets"]],
                    "multiple_choice_targets": [
                        targets.decode().strip() for targets in example["multiple_choice_targets"].numpy()
                    ],
                    "multiple_choice_scores": [scores for scores in example["multiple_choice_scores"].numpy()],
                }