"""Chunked tokenization experiment."""
import os
from os.path import join as p_join


from datasets import load_dataset
import torch
import pandas as pd
from multibanddiffusion import MultiBandDiffusion

# configure experiment
cache_dir = p_join("experiment", "chunk_encoder")
os.makedirs(cache_dir, exist_ok=True)
num_codes = 3
mbd_model = MultiBandDiffusion.from_pretrained(num_codebooks_decoder=num_codes, num_codebooks_encoder=num_codes)
configs = [
    [32000, 32000],  # 1.3 sec chunk, 1.3 sec stride
    [32000, 28800],  # 1.3 sec chunk, 1.15 sec stride (32000 - 320 * 10)
    [32000, 25600],  # 1.3 sec chunk, 1 sec stride (32000 - 320 * 20)
    [64000, 64000],  # 2.6 sec chunk, 2.6 sec stride
    [64000, 60800],  # 2.6 sec chunk, 2.45 sec stride (64000 - 320 * 10)
    [64000, 57600],  # 2.6 sec chunk, 2.3 sec stride (64000 - 320 * 20)
]


def test_hf(hf_dataset: str, sample_size: int = 128, batch_size: int = 32):
    dataset = load_dataset(hf_dataset, split="test")
    dataset = dataset.select(range(sample_size))
    dataset = dataset.map(
        lambda batch: {k: [v] for k, v in batch.items()},
        batched=True,
        batch_size=batch_size
    )
    full_accuracy_table = []
    for data in dataset:
        sr_list = [d["sampling_rate"] for d in data["audio"]]
        assert len(set(sr_list)) == 1, sr_list
        sr = sr_list[0]
        array = [d["array"] for d in data["audio"]]
        max_length = max([len(a) for a in array])
        array = [a + [0] * (max_length - len(a)) for a in array]
        wav = torch.as_tensor(array, dtype=torch.float32).unsqueeze_(1)
        tokens_original = mbd_model.wav_to_tokens(wav, sr)
        total_vars = tokens_original.shape.numel()
        accuracy_table = {}
        for chunk, stride in configs:
            tokens = mbd_model.wav_to_tokens(wav, sr, chunk_length=chunk, stride=stride)
            assert tokens_original.shape == tokens.shape, f"{tokens_original.shape} != {tokens.shape}"
            accuracy = {"full": (tokens_original == tokens).sum().item() / total_vars * 100}
            accuracy.update({f"code_{c + 1}": (tokens_original[0, c, :] == tokens[0, c, :]).sum().item() / tokens_original.shape[2] * 100 for c in range(num_codes)})
            accuracy_table[f"chunk_{chunk}.stride_{stride}"] = accuracy
        full_accuracy_table.append(accuracy_table)
    df_accuracy = sum(pd.DataFrame(accuracy_table) for accuracy_table in full_accuracy_table)/len(full_accuracy_table)
    df_accuracy.to_csv(p_join(cache_dir, f"token_accuracy.{os.path.basename(hf_dataset)}.{num_codes}codes.csv"))


if __name__ == '__main__':
    test_hf("japanese-asr/ja_asr.reazonspeech_test", sample_size=64, batch_size=16)
    test_hf("japanese-asr/ja_asr.jsut_basic5000", sample_size=64, batch_size=16)