import json
import os
import tarfile
import zipfile
import gzip
import subprocess
from os.path import join as p_join
from math import ceil, floor
from tqdm import tqdm
from multiprocessing import Pool
from typing import Optional, Dict
from glob import glob
# import librosa

import pandas as pd
import soundfile as sf
from datasets import Dataset, Audio, DatasetDict

audio_loader = Audio()
# dataset config
url_metadata_dict = {
    "enA-jpn": "https://dl.fbaipublicfiles.com/seamless/data/seamless.dataset.metadata.public.enA-jpn.withduration.tsv.gz"
}
direction_speech = os.getenv("DIRECTION_SPEECH", "enA")
direction_text = os.getenv("DIRECTION_TEXT", "jpn")
direction = f"{direction_speech}-{direction_text}"
if direction not in url_metadata_dict:
    url_metadata_dict[direction] = f"https://dl.fbaipublicfiles.com/seamless/data/seamless.dataset.metadata.public.{direction}.withduration.tsv.gz"
cache_dir_feature = p_join("download", "feature", direction)
cache_dir_audio = p_join("download", "audio", direction)
os.makedirs(cache_dir_feature, exist_ok=True)
os.makedirs(p_join(cache_dir_audio, direction_speech), exist_ok=True)
# processor config
n_pool = int(os.getenv("N_POOL", 1))
wget_max_retry = os.getenv("MAX_RETRY", "2")
wget_timeout = os.getenv("TIMEOUT", "20")
line_no_start = int(os.getenv("LINE_NO_START", 0))
line_no_end = int(os.getenv("LINE_NO_END", 10000))
dataset_id = os.getenv("DATASET_ID", 0)
hf_org = os.getenv("HF_ORG", "asahi417")
hf_dataset = f"seamless-align-{direction}"
skip_download = bool(int(os.getenv("SKIP_DOWNLOAD", 0)))
sampling_rate = 16000  # seamless-align aligns audio in 16kHz

text_corpus = p_join("text_corpus", f"text.{direction_speech}-{direction_text}.json")
assert os.path.exists(text_corpus)
with open(text_corpus) as f:
    line_no_to_text = json.load(f)


def wget(url: str, output_file: Optional[str] = None):
    os.makedirs(os.path.dirname(output_file), exist_ok=True)
    subprocess.run(["wget", url, "-O", output_file, "--tries", wget_max_retry, "--timeout", wget_timeout])
    if not os.path.exists(output_file):
        return False
    if output_file.endswith('.tar.gz') or output_file.endswith('.tgz') or output_file.endswith('.tar'):
        if output_file.endswith('.tar'):
            tar = tarfile.open(output_file)
        else:
            tar = tarfile.open(output_file, "r:gz")
        tar.extractall(os.path.dirname(output_file))
        tar.close()
        os.remove(output_file)
    elif output_file.endswith('.gz'):
        with gzip.open(output_file, 'rb') as f:
            with open(output_file.replace('.gz', ''), 'wb') as f_write:
                f_write.write(f.read())
        os.remove(output_file)
    elif output_file.endswith('.zip'):
        with zipfile.ZipFile(output_file, 'r') as zip_ref:
            zip_ref.extractall()
        os.remove(output_file)
    return True


def get_metadata():
    url_metadata = url_metadata_dict[direction]
    meta_data_filename = os.path.basename(url_metadata)
    meta_data_path = p_join("download", "meta", meta_data_filename)
    if not os.path.exists(meta_data_path.replace(".gz", "")):
        assert wget(url_metadata, output_file=meta_data_path)
    df = pd.read_csv(meta_data_path.replace(".gz", ""), sep=r'[\t\s]', header=None)
    df = df[[0, 2, 3, 4, 9, 10, 11, 12]]
    df.columns = ["id", "url", "duration_start", "duration_end", "laser_score", "direction", "side", "line_no"]
    if direction == "enA-jpn":
        df = df[df["side"] == "enA"]
    assert len(df["direction"].unique()) == 1
    df.pop("direction")
    return df.sort_values(by=["line_no", "side"])


def to_json_serializable(val):
    if "float" in str(type(val)):
        return float(val)
    if "int" in str(type(val)):
        return int(val)
    return str(val)


def cleanup(features, feature_file):
    if os.path.exists(feature_file):
        os.remove(feature_file)
    for _unrelated_audio_file in glob(p_join(cache_dir_audio, direction_speech, f"{features['line_no']}.*")):
        os.remove(_unrelated_audio_file)
    # create a dummy so that we can skip from next run
    with open(feature_file, "w") as f:
        json.dump({"dummy": "dummy"}, f)


def get_audio(dataframe: pd.DataFrame):
    features = {"line_no": int(dataframe.pop('line_no').values[0])}
    if features["line_no"] not in text_corpus:
        return None
    features[f"{direction_text}.text"] = text_corpus[features["line_no"]]
    feature_file = p_join(cache_dir_feature, f'{features["line_no"]}.json')
    features.update({f"{direction_speech}.{k}": to_json_serializable(v) for k, v in dataframe.iloc[0].to_dict().items()})
    identifier = os.path.basename(features[f"{direction_speech}.url"]).split(".")[-1]
    features[f"{direction_speech}.path"] = p_join(
        cache_dir_audio, direction_speech, f"{features['line_no']}.{identifier}"
    )
    start, end = features[f"{direction_speech}.duration_start"], features[f"{direction_speech}.duration_end"]
    if not os.path.exists(features[f"{direction_speech}.path"]):
        print(f"WGET {features[f'{direction_speech}.url']}")
        flag = wget(features[f"{direction_speech}.url"], output_file=features[f"{direction_speech}.path"])
        if not flag:
            print("\n#### ERROR: wget failure ####\n")
            cleanup(features, feature_file)
            return None
        else:
            try:
                print(f"LOAD AUDIO FROM {features[f'{direction_speech}.path']}")
                wav, sr = sf.read(features[f"{direction_speech}.path"])
                print(f"wav shape:{wav.shape}")
                if wav.ndim > 1:
                    wav = wav[:, 0]
                wav = wav[floor(start / sampling_rate * sr):ceil(end / sampling_rate * sr)]
                print(f"wav shape (after truncate):{wav.shape}")
                wav = wav[:int(end/sampling_rate * sr) + sr]
                print(f"SAVING: {features[f'{direction_speech}.path']}")
                sf.write(features[f"{direction_speech}.path"], wav, sr)

            except Exception as e:
                print(f"\n#### ERROR ####\n {e}")
                cleanup(features, feature_file)
                return None
    print(f"\n### SUCCESS! ###\n:{features['line_no']}")
    with open(feature_file, "w") as f:
        json.dump(features, f)
    return features["line_no"]


def loader(feature: str) -> Dict:
    with open(feature) as f_reader:
        return json.load(f_reader)


if __name__ == '__main__':
    if not skip_download:
        df_metadata = get_metadata()
        print(f"metadata: {len(df_metadata)}, {line_no_start} --> {line_no_end}")
        inputs = [
            g for line_no, g in df_metadata.groupby("line_no")
            if line_no_start <= line_no < line_no_end and not os.path.exists(
                p_join(cache_dir_feature, f'{int(line_no)}.json')
            )
        ]
        print(f"filtered unique lines: {len(inputs)}")
        inputs = [g for g in inputs if len(g) == 1]
        if n_pool == 1:
            for g in tqdm(inputs, total=len(inputs)):
                line_no = get_audio(g)
        else:
            with Pool(n_pool) as pool:
                for line_no in pool.imap_unordered(get_audio, inputs):
                    if line_no:
                        print(line_no)

    print("UPLOADING TO HF!!!")
    features = [p_join(cache_dir_feature, f'{i}.json') for i in range(line_no_start, line_no_end)]
    print(f"- raw feature: {len(features)}")
    features = [i for i in features if os.path.exists(i)]
    print(f"- path exists: {len(features)}")
    features = [loader(i) for i in features]
    features = [i for i in features if "dummy" not in i]
    print(f"- dummy removed: {len(features)}")
    print(f"push {len(features)} records to hub")
    data_dict = {}
    data_dict.update({f"{direction_speech}.audio": [i.pop(f"{direction_speech}.path") for i in features]})
    data_dict.update({k: [i[k] for i in features] for k in features[0].keys()})
    audio_dataset = Dataset.from_dict(data_dict)
    audio_dataset = audio_dataset.cast_column(f"{direction_speech}.audio", Audio())
    DatasetDict({"train": audio_dataset}).push_to_hub(
        f"{hf_org}/{hf_dataset}",
        config_name=f"subset_{dataset_id}"
    )