from pathlib import Path
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import librosa
import librosa.display
from sklearn.metrics import roc_auc_score
import warnings
warnings.filterwarnings("ignore")

DATA_DIR = Path("output/voiceguard")
AUDIO_DIR = DATA_DIR
SR = 16_000
DURATION = 4          # seconds
N_SAMPLES = SR * DURATION  # 64 000


train_df = pd.read_csv(DATA_DIR / "train.csv")
test_df  = pd.read_csv(DATA_DIR / "test.csv")

print("Train shape:", train_df.shape)
print("Test  shape:", test_df.shape)
print()
print(train_df.head())


counts = train_df["label"].value_counts().sort_index()
print("Label counts (0=real, 1=fake):")
print(counts)
print(f"\nClass balance — real: {counts[0]}, fake: {counts[1]}, ratio: {counts[1]/counts[0]:.2f}")

fig, ax = plt.subplots(figsize=(5, 3))
ax.bar(["real (0)", "fake (1)"], [counts[0], counts[1]], color=["steelblue", "tomato"])
ax.set_ylabel("Count")
ax.set_title("Train set class balance")
plt.tight_layout()
plt.show()


def load_audio(path, sr=SR, n_samples=N_SAMPLES):
    y, _ = librosa.load(path, sr=sr, mono=True)
    if len(y) < n_samples:
        y = np.pad(y, (0, n_samples - len(y)))
    else:
        y = y[:n_samples]
    return y


def spectral_flatness_mean(path):
    y = load_audio(path)
    sf = librosa.feature.spectral_flatness(y=y)
    return float(np.mean(sf))

real_rows = train_df[train_df["label"] == 0].sample(min(200, (train_df["label"]==0).sum()), random_state=42)
fake_rows = train_df[train_df["label"] == 1].sample(min(200, (train_df["label"]==1).sum()), random_state=42)

print("Computing spectral flatness for real samples …")
real_sf = [spectral_flatness_mean(AUDIO_DIR / r["id"]) for _, r in real_rows.iterrows()]
print("Computing spectral flatness for fake samples …")
fake_sf = [spectral_flatness_mean(AUDIO_DIR / r["id"]) for _, r in fake_rows.iterrows()]

print(f"Real  — mean: {np.mean(real_sf):.4f}  std: {np.std(real_sf):.4f}")
print(f"Fake  — mean: {np.mean(fake_sf):.4f}  std: {np.std(fake_sf):.4f}")


fig, ax = plt.subplots(figsize=(7, 4))
ax.hist(real_sf, bins=30, alpha=0.6, color="steelblue", label="real")
ax.hist(fake_sf, bins=30, alpha=0.6, color="tomato",    label="fake")
ax.set_xlabel("Spectral Flatness (mean)")
ax.set_ylabel("Count")
ax.set_title("Spectral Flatness Distribution: Real vs Fake")
ax.legend()
plt.tight_layout()
plt.show()


real_path = AUDIO_DIR / real_rows.iloc[0]["id"]
fake_path = AUDIO_DIR / fake_rows.iloc[0]["id"]

y_real = load_audio(real_path)
y_fake = load_audio(fake_path)

fig, axes = plt.subplots(2, 2, figsize=(12, 6))
t = np.linspace(0, DURATION, N_SAMPLES)

# Waveforms
axes[0, 0].plot(t, y_real, lw=0.4, color="steelblue")
axes[0, 0].set_title("Waveform — Real")
axes[0, 0].set_xlabel("Time (s)")

axes[0, 1].plot(t, y_fake, lw=0.4, color="tomato")
axes[0, 1].set_title("Waveform — Fake")
axes[0, 1].set_xlabel("Time (s)")

# Mel spectrograms
for ax, y, label, cmap in [
    (axes[1, 0], y_real, "Real", "Blues"),
    (axes[1, 1], y_fake, "Fake", "Reds"),
]:
    mel = librosa.feature.melspectrogram(y=y, sr=SR, n_mels=80, n_fft=512, hop_length=128)
    mel_db = librosa.power_to_db(mel, ref=np.max)
    img = librosa.display.specshow(mel_db, sr=SR, hop_length=128, x_axis="time",
                                   y_axis="mel", ax=ax, cmap=cmap)
    ax.set_title(f"Mel Spectrogram — {label}")
    fig.colorbar(img, ax=ax, format="%+2.0f dB")

plt.tight_layout()
plt.show()


def hnr_autocorr(y, sr=SR, fmin=75, fmax=400):
    """Estimate HNR via autocorrelation (PRAAT-inspired)."""
    frame_len = int(sr * 0.04)   # 40 ms frames
    hop = int(sr * 0.01)         # 10 ms hop
    hnrs = []
    for start in range(0, len(y) - frame_len, hop):
        frame = y[start : start + frame_len]
        frame = frame * np.hanning(len(frame))
        r = np.correlate(frame, frame, mode="full")
        r = r[len(r) // 2 :]      # keep non-negative lags
        r0 = r[0] + 1e-8
        # search for peak in plausible pitch range
        min_lag = int(sr / fmax)
        max_lag = int(sr / fmin)
        if max_lag >= len(r):
            continue
        r_search = r[min_lag:max_lag]
        if len(r_search) == 0:
            continue
        r_max = r_search.max()
        hnr = 10 * np.log10(r_max / (r0 - r_max + 1e-8))
        hnrs.append(hnr)
    return float(np.mean(hnrs)) if hnrs else 0.0

print("Computing HNR …")
real_hnr = [hnr_autocorr(load_audio(AUDIO_DIR / r["id"])) for _, r in real_rows.iterrows()]
fake_hnr = [hnr_autocorr(load_audio(AUDIO_DIR / r["id"])) for _, r in fake_rows.iterrows()]

print(f"Real  HNR — mean: {np.mean(real_hnr):.2f} dB  std: {np.std(real_hnr):.2f}")
print(f"Fake  HNR — mean: {np.mean(fake_hnr):.2f} dB  std: {np.std(fake_hnr):.2f}")

fig, ax = plt.subplots(figsize=(7, 4))
ax.hist(real_hnr, bins=30, alpha=0.6, color="steelblue", label="real")
ax.hist(fake_hnr, bins=30, alpha=0.6, color="tomato",    label="fake")
ax.set_xlabel("HNR (dB)")
ax.set_ylabel("Count")
ax.set_title("HNR Distribution: Real vs Fake")
ax.legend()
plt.tight_layout()
plt.show()


submission = pd.DataFrame({
    "id":    test_df["id"],
    "score": 0.5,          # placeholder P(fake)
})
print(submission.head())
print("\nSubmission shape:", submission.shape)
# submission.to_csv("submission_starter.csv", index=False)