# Copyright 2024 RealNetworks

# 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.


from pathlib import Path
from typing import (
    Any,
    Dict,
    Iterable,
    List,
    Tuple,
)

from datasets import (
    Audio,
    BuilderConfig,
    DatasetInfo,
    Features,
    GeneratorBasedBuilder,
    Split,
    SplitGenerator,
    Value,
)
from datasets.download.download_manager import (
    ArchiveIterable,
    DownloadManager,
)


class FLEURSHSConfig(BuilderConfig):
    def __init__(
        self,
        name,
        **kwargs,
    ):
        super(
            FLEURSHSConfig,
            self,
        ).__init__(
            name=name,
            **kwargs,
        )


class FLEURSHSDataset(GeneratorBasedBuilder):
    DEFAULT_CONFIG_NAME = "en_us"

    BUILDER_CONFIGS = [
        FLEURSHSConfig(name=name)
        for name in (
            "de_de",
            "en_us",
            "es_419",
            "fr_fr",
            "it_it",
            "nl_nl",
            "pl_pl",
            "sv_se",
        )
    ]

    def get_audio_archive_path(
        self,
        split: str,
    ) -> Path:
        return Path("data") / self.config.name / "splits" / f"{split}.tar.gz"

    def _info(self) -> DatasetInfo:
        return DatasetInfo(
            description="FLEURS Human-Synthetic classification dataset",
            features=Features(
                {
                    "audio": Audio(sampling_rate=16000),
                    "label": Value("string"),
                }
            ),
            supervised_keys=None,
            homepage="https://huggingface.co/datasets/realnetworks-kontxt/fleurs-hs",
            license="CC BY 4.0",
            citation="\n".join(
                (
                    "@inproceedings{dropuljic-ssdww2v2ivls",
                    "author={Dropuljić, Branimir and Šuflaj, Miljenko and Jertec, Andrej and Obadić, Leo}",
                    "booktitle={2024 IEEE International Conference on Acoustics, Speech, and Signal Processing Workshops (ICASSPW)}",
                    "title={Synthetic speech detection with Wav2Vec 2.0 in various language settings}",
                    "year={2024}",
                    "volume={}",
                    "number={}",
                    "pages={1-5}",
                    "keywords={Synthetic speech detection;text-to-speech;wav2vec 2.0;spoofing attack;multilingualism}",
                    "doi={}",  # TODO: Add DOI once known
                    "}",
                )
            ),
        )

    def _split_generators(
        self,
        download_manager: DownloadManager,
    ) -> List[SplitGenerator]:
        archive_iterables = {
            split: str(self.get_audio_archive_path(split=split))
            for split in (
                "train",
                "dev",
                "test",
            )
        }
        archive_iterables = download_manager.download(archive_iterables)
        archive_iterables = {
            split: download_manager.iter_archive(path)
            for split, path in archive_iterables.items()
        }

        return [
            SplitGenerator(
                name=Split.TRAIN,
                gen_kwargs={
                    "archive_iterable": archive_iterables["train"],
                },
            ),
            SplitGenerator(
                name=Split.VALIDATION,
                gen_kwargs={
                    "archive_iterable": archive_iterables["dev"],
                },
            ),
            SplitGenerator(
                name=Split.TEST,
                gen_kwargs={
                    "archive_iterable": archive_iterables["test"],
                },
            ),
        ]

    def _generate_examples(
        self,
        archive_iterable: ArchiveIterable,
    ) -> Iterable[Tuple[int, Dict[str, Any]]]:
        current_index = 0
        for audio_path, audio_file in archive_iterable:
            audio = {
                "path": audio_path,
                "bytes": audio_file.read(),
            }

            # Samples are located in one of 2 folders:
            # - 'human'
            # - 'synthetic`
            #
            # Therefore the label is the name of their parent folder
            label = Path(audio_path).parent.name

            yield current_index, {
                "audio": audio,
                "label": label,
            }
            current_index += 1