import argparse
import os
from typing import Tuple


def _validate_dataset(root: str, metadata_name: str, wavs_subdir: str) -> Tuple[int, int, int]:
    valid_lines = 0
    invalid_lines = 0
    missing_wavs = 0

    metadata_path = os.path.join(root, metadata_name)
    if not os.path.isfile(metadata_path):
        msg = f"metadata file not found: {metadata_path}"
        raise FileNotFoundError(msg)

    wavs_root = os.path.join(root, wavs_subdir)
    if not os.path.isdir(wavs_root):
        msg = f"wavs directory not found: {wavs_root}"
        raise FileNotFoundError(msg)

    with open(metadata_path, encoding="utf-8-sig") as f:
        for idx, raw_line in enumerate(f, start=1):
            line = raw_line.strip()
            if not line:
                continue

            parts = line.split("|")
            if len(parts) != 3:
                invalid_lines += 1
                print(f"[line {idx}] invalid field count ({len(parts)} != 3): {line}")
                continue

            file_id, normalized_text, original_text = parts
            file_id = file_id.strip()
            normalized_text = normalized_text.strip()
            original_text = original_text.strip()

            if not file_id or any(sep in file_id for sep in ("/", "\\")):
                invalid_lines += 1
                print(f"[line {idx}] invalid file_id: {file_id!r}")
                continue

            if not normalized_text:
                invalid_lines += 1
                print(f"[line {idx}] empty normalized_text")
                continue

            if not original_text:
                invalid_lines += 1
                print(f"[line {idx}] empty original_text")
                continue

            wav_path = os.path.join(wavs_root, f"{file_id}.wav")
            if not os.path.isfile(wav_path):
                missing_wavs += 1
                print(f"[line {idx}] missing wav file: {wav_path}")

            valid_lines += 1

    return valid_lines, invalid_lines, missing_wavs


def main() -> None:
    parser = argparse.ArgumentParser(description="Validate an LJSpeech-style dataset folder.")
    parser.add_argument(
        "--root",
        required=True,
        help="Path to LJSpeech dataset root containing wavs/ and metadata.csv.",
    )
    parser.add_argument(
        "--metadata",
        default="metadata.csv",
        help="Metadata filename relative to root (default: metadata.csv).",
    )
    parser.add_argument(
        "--wavs-subdir",
        default="wavs",
        help="Subdirectory under root containing wav files (default: wavs).",
    )
    args = parser.parse_args()

    root = os.path.abspath(args.root)
    if not os.path.isdir(root):
        msg = f"dataset root is not a directory: {root}"
        raise NotADirectoryError(msg)

    print(f"Validating LJSpeech dataset in: {root}")
    print(f"  metadata: {args.metadata}")
    print(f"  wavs subdir: {args.wavs_subdir}")

    valid, invalid, missing = _validate_dataset(root, args.metadata, args.wavs_subdir)

    print()
    print(f"Valid lines     : {valid}")
    print(f"Invalid lines   : {invalid}")
    print(f"Missing wav files: {missing}")

    if invalid or missing:
        raise SystemExit(1)


if __name__ == "__main__":
    main()