main.py

#!/usr/bin/env python3
"""
Lyric time-sync player.

Isi daftar `LYRICS` dengan tuple (time_in_seconds, "lyric text").
Contoh:
LYRICS = [
    (0.0, "Bait pertama"),
    (5.2, "Bait kedua"),
]

Jalankan: python main.py --speed 1.0 --start 0.0
- --speed: percepat/pelankan pemutaran (mis. 2.0 = dua kali lipat)
- --start: mulai dari offset (detik)
"""

from __future__ import annotations

import time
import argparse
import sys
from typing import List, Tuple

# --- RUANG UNTUK LIRIK ---
# Tempelkan lirik dan waktu di bawah ini sebagai daftar tuple (detik, teks)
# Contoh:
# LYRICS = [
#     (0.0, "Bait pembuka..."),
#     (4.5, "Lirik selanjutnya..."),
#     (9.2, "Reff..."),
# ]
# Pastikan angka waktunya berada dalam satuan detik (float atau int)
LYRICS: List[Tuple[float, str]] = [
    (0.0, "Teman ku semua pada jahat tante"),
    (4.0, "aku lagi susah mereka gak ada"),
    (8.0, "coba kalau lagi jaya"),
    (11.2, "aku di puja puja nya tante"),
    (15.0, "sudah terbiasa terjadi tante"), 
    (18.0, "teman datang ketika lagi butuh saja"),
    (22.5,"coba kalau lagi susah"),
    (25.6,"mereka semua menghilang"),
]


def _format_ts(sec: float) -> str:
    """Formatkan waktu (detik) ke MM:SS(.cc)

    Menambahkan dua digit pecahan detik jika ada pecahan (centiseconds).
    """
    if sec < 0:
        sec = 0
    minutes = int(sec) // 60
    seconds = int(sec) % 60
    frac = sec - int(sec)
    if frac:
        hundredths = int(round(frac * 100))
        return f"{minutes:02d}:{seconds:02d}.{hundredths:02d}"
    return f"{minutes:02d}:{seconds:02d}"


def play(lyrics: List[Tuple[float, str]], speed: float = 1.0, start_offset: float = 0.0) -> None:
    """Mainkan lirik berdasarkan waktu (detik) (mode baris biasa).

    Args:
        lyrics: daftar (time_in_seconds, text)
        speed: pengali kecepatan pemutaran (1.0 = normal)
        start_offset: mulai dari offset (detik)
    """
    if not lyrics:
        print("Tidak ada lirik. Isi daftar LYRICS pada file.", file=sys.stderr)
        return

    lyrics_sorted = sorted(lyrics, key=lambda x: x[0])

    # Waktu dasar: ketika fungsi dipanggil
    start_time = time.time() - (start_offset / speed)

    for t, text in lyrics_sorted:
        target_time = start_time + (t / speed)
        to_sleep = target_time - time.time()
        if to_sleep > 0:
            time.sleep(to_sleep)
        print(f"[{_format_ts(t)}] {text}", flush=True)


def _expand_per_word(lyrics_sorted: List[Tuple[float, str]], default_gap: float = 2.0) -> List[Tuple[float, int, str]]:
    """Perluas lirik per-baris menjadi event per-kata.

    Mengembalikan list tuple (word_time, line_index, word).
    Kata-kata didistribusikan merata antara waktu baris saat ini dan baris berikutnya.
    Untuk baris terakhir, digunakan `default_gap` untuk menentukan interval.
    """
    events: List[Tuple[float, int, str]] = []
    n_lines = len(lyrics_sorted)
    for i, (t, text) in enumerate(lyrics_sorted):
        next_t = lyrics_sorted[i + 1][0] if (i + 1) < n_lines else t + default_gap
        delta = max(0.0, next_t - t)
        words = text.split()
        m = len(words)
        if m == 0:
            continue
        if delta <= 0 or m == 1:
            # Semua kata muncul bersama pada waktu baris
            for w in words:
                events.append((t, i, w))
        else:
            for j, w in enumerate(words):
                wt = t + delta * (j / m)
                events.append((wt, i, w))
    return events


def play_per_word(lyrics: List[Tuple[float, str]], speed: float = 1.0, start_offset: float = 0.0, default_gap: float = 2.0) -> None:
    """Mainkan lirik per-kata, memperbarui setiap baris di terminal secara in-place.

    Kata-kata disusun berdasarkan baris aslinya dan muncul sesuai event yang dihasilkan
    oleh `_expand_per_word`.
    """
    if not lyrics:
        print("Tidak ada lirik. Isi daftar LYRICS pada file.", file=sys.stderr)
        return

    lyrics_sorted = sorted(lyrics, key=lambda x: x[0])
    events = sorted(_expand_per_word(lyrics_sorted, default_gap=default_gap), key=lambda x: x[0])
    start_time = time.time() - (start_offset / speed)

    # State per baris
    lines_state: dict[int, list[str]] = {}
    lines_count = len(lyrics_sorted)

    # Cetak header awal (waktu) dan baris kosong agar kita bisa menulis in-place
    for t, _ in lyrics_sorted:
        print(f"[{_format_ts(t)}] ")

    for wt, idx, word in events:
        target_time = start_time + (wt / speed)
        to_sleep = target_time - time.time()
        if to_sleep > 0:
            time.sleep(to_sleep)
        # update state
        lines_state.setdefault(idx, []).append(word)

        # pindah kursor ke atas sebanyak lines_count agar kita menimpa semua baris
        sys.stdout.write(f"\x1b[{lines_count}A")
        for li in range(lines_count):
            base_time = lyrics_sorted[li][0]
            line_words = " ".join(lines_state.get(li, []))
            sys.stdout.write(f"[{_format_ts(base_time)}] {line_words}\x1b[K\n")
        sys.stdout.flush()

    # Setelah selesai, pastikan kursor berada setelah output
    print("\nSelesai.")


def main() -> None:
    parser = argparse.ArgumentParser(description="Lyric time-sync player")
    parser.add_argument("--speed", type=float, default=1.0, help="Playback speed multiplier")
    parser.add_argument("--start", type=float, default=0.0, help="Start offset in seconds")
    parser.add_argument("--per-word", action="store_true", help="Tampilkan lirik per-kata (karaoke-style)")
    parser.add_argument("--default-gap", type=float, default=2.0, help="Interval (detik) yang digunakan untuk baris terakhir saat --per-word")
    args = parser.parse_args()

    if not LYRICS:
        print("Tidak ada lirik di daftar `LYRICS`. Tambahkan lirik dan jalankan lagi.", file=sys.stderr)
        sys.exit(1)

    try:
        if args.per_word:
            play_per_word(LYRICS, speed=args.speed, start_offset=args.start, default_gap=args.default_gap)
        else:
            play(LYRICS, speed=args.speed, start_offset=args.start)
    except KeyboardInterrupt:
        print("\nDibatalkan oleh pengguna.")


if __name__ == "__main__":
    main()