import sys, os, time, threading
from openai import OpenAI

client = OpenAI()

audio_path = sys.argv[1]
total_size = os.path.getsize(audio_path)
size_mb = total_size / (1024 * 1024)


import io

class ProgressFile(io.RawIOBase):
    """File wrapper that reports upload progress as bytes are read."""
    def __init__(self, path):
        self._f = open(path, "rb")
        self.name = path
        self.read_bytes = 0

    def readable(self):
        return True

    def seekable(self):
        return True

    def seek(self, *args):
        return self._f.seek(*args)

    def tell(self):
        return self._f.tell()

    def read(self, size=-1):
        chunk = self._f.read(size)
        self.read_bytes += len(chunk)
        return chunk

    def readinto(self, b):
        n = self._f.readinto(b)
        self.read_bytes += n or 0
        return n

    def close(self):
        self._f.close()
        super().close()


pf = ProgressFile(audio_path)
phase = {"processing_start": None}
done = False


def ticker():
    start = time.time()
    while not done:
        if pf.read_bytes < total_size:
            pct = pf.read_bytes / total_size * 100
            mb = pf.read_bytes / (1024 * 1024)
            print(f"\r  Uploading: {pct:5.1f}%  ({mb:.1f}/{size_mb:.1f} MB)      ",
                  end="", flush=True)
        else:
            if phase["processing_start"] is None:
                phase["processing_start"] = time.time()
            m, s = divmod(int(time.time() - phase["processing_start"]), 60)
            print(f"\r  Upload complete. Processing on OpenAI servers: {m:02d}:{s:02d}      ",
                  end="", flush=True)
        time.sleep(0.5)


print(f"File: {audio_path} ({size_mb:.1f} MB)")
t = threading.Thread(target=ticker, daemon=True)
t.start()

try:
    transcript = client.audio.transcriptions.create(
        model="gpt-4o-transcribe-diarize",
        file=pf,
        response_format="diarized_json",
        chunking_strategy="auto",
    )
finally:
    done = True
    t.join()
    pf.close()
    print()

print("\nResponse received. Writing dialogue...\n")


def fmt(t):
    h, rem = divmod(int(t), 3600)
    m, s = divmod(rem, 60)
    return f"{h:02d}:{m:02d}:{s:02d}"


out_path = audio_path.rsplit(".", 1)[0] + "_dialogue.txt"
with open(out_path, "w") as out:
    for seg in transcript.segments:
        line = f"[{fmt(seg.start)} - {fmt(seg.end)}] Speaker {seg.speaker}: {seg.text.strip()}"
        print(line)
        out.write(line + "\n")

print(f"\nDone. {len(transcript.segments)} segments saved to {out_path}")