import csv
from pathlib import Path


ROOT = Path(__file__).resolve().parents[1]
GOLD_PATH = ROOT / "data" / "gold.tsv"
PREDICTIONS_PATH = ROOT / "data" / "predictions.tsv"
PHONEME_CHARS = set("abdefhijklmnopstuvwzɡʁʃʒʔˈχ")
PHONEME_TRANSLATION = str.maketrans({"x": "χ", "r": "ʁ", "g": "ɡ"})


def normalize_phonemes(text):
    text = text.translate(PHONEME_TRANSLATION)
    return "".join(char for char in text if char in PHONEME_CHARS)


def read_tsv(path):
    if not path.exists() or path.stat().st_size == 0:
        return []
    with path.open("r", encoding="utf-8-sig", newline="") as f:
        return list(csv.DictReader(f, delimiter="\t"))


def read_predictions(path):
    if not path.exists() or path.stat().st_size == 0:
        return []
    with path.open("r", encoding="utf-8-sig", newline="") as f:
        return list(csv.DictReader(f, delimiter="\t"))


def write_predictions(path, rows, fieldnames):
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", encoding="utf-8", newline="") as f:
        writer = csv.DictWriter(f, delimiter="\t", fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)


def parse_label(label):
    targets = {}
    for part in label.split():
        if "=" not in part:
            continue
        index, ipa = part.split("=", 1)
        targets[int(index)] = normalize_phonemes(ipa)
    return targets


def indexed_prediction(gold_row, phonemes):
    phoneme_tokens = phonemes.split()
    parts = []
    for index in parse_label(gold_row["Label"]):
        pred = normalize_phonemes(phoneme_tokens[index]) if index < len(phoneme_tokens) else ""
        parts.append(f"{index}={pred}")
    return " ".join(parts)


def load_prediction_rows():
    gold_rows = read_tsv(GOLD_PATH)
    pred_rows = read_predictions(PREDICTIONS_PATH)

    if not pred_rows:
        pred_rows = [{} for _ in gold_rows]

    if len(pred_rows) != len(gold_rows):
        raise ValueError(
            "Predictions must have the same number of rows as gold: "
            f"got {len(pred_rows)}, expected {len(gold_rows)}."
        )

    return gold_rows, pred_rows


def update_prediction_column(column_name, predict):
    gold_rows, pred_rows = load_prediction_rows()

    for gold_row, pred_row in zip(gold_rows, pred_rows):
        phonemes = predict(gold_row["Text"])
        pred_row[column_name] = indexed_prediction(gold_row, phonemes)

    fieldnames = []
    for row in pred_rows:
        for key in row:
            if key not in fieldnames:
                fieldnames.append(key)

    write_predictions(PREDICTIONS_PATH, pred_rows, fieldnames)
    print(f"Updated {PREDICTIONS_PATH} column: {column_name}")