app.py

import os
import sys
import threading
import numpy as np
import soundfile as sf
import shutil
import librosa
import gradio as gr

# torch and NeuTTSAir imported lazily in get_tts() to avoid slow startup / OOM on Render

# ---------------------------
# eSpeak check (Windows + Linux)
# ---------------------------
def check_espeak_installed():
    # If already set (e.g. by Docker), trust it
    if os.environ.get("PHONEMIZER_ESPEAK_LIBRARY") and os.path.exists(os.environ["PHONEMIZER_ESPEAK_LIBRARY"]):
        print(f"Using espeak library from env: {os.environ['PHONEMIZER_ESPEAK_LIBRARY']}")
        return True

    # Linux: look for libespeak-ng.so in common locations
    if sys.platform != "win32":
        so_names = ["libespeak-ng.so", "libespeak-ng.so.1", "libespeak.so"]
        search_dirs = ["/usr/lib", "/usr/lib/x86_64-linux-gnu", "/usr/local/lib"]
        for d in search_dirs:
            if not os.path.isdir(d):
                continue
            for name in so_names:
                candidate = os.path.join(d, name)
                if os.path.exists(candidate):
                    os.environ["PHONEMIZER_ESPEAK_LIBRARY"] = candidate
                    print(f"Found espeak library at: {candidate}")
                    return True
        if shutil.which("espeak-ng") or shutil.which("espeak"):
            print("Found espeak-ng in PATH (phonemizer may use default library)")
            return True
        print("\nError: espeak-ng not found! On Linux install with: apt-get install espeak-ng libespeak-ng-dev")
        return False

    # Windows
    possible_paths = [
        "C:\\Program Files\\eSpeak NG",
        "C:\\Program Files (x86)\\eSpeak NG",
        "C:\\Program Files\\eSpeak",
        "C:\\Program Files (x86)\\eSpeak",
    ]
    dll_names = ['libespeak-ng.dll', 'espeak-ng.dll', 'libespeak.dll', 'espeak.dll']
    for exe_cmd in ['espeak-ng', 'espeak']:
        exe_path = shutil.which(exe_cmd)
        if exe_path:
            print(f"Found {exe_cmd} in PATH at: {exe_path}")
            exe_dir = os.path.dirname(exe_path)
            for dll in dll_names:
                candidate = os.path.join(exe_dir, dll)
                if os.path.exists(candidate):
                    os.environ['PHONEMIZER_ESPEAK_LIBRARY'] = candidate
                    print(f"Found espeak shared library at: {candidate}")
                    return True

    for path in possible_paths:
        if os.path.exists(path):
            for root, _, files in os.walk(path):
                for dll in dll_names:
                    candidate = os.path.join(root, dll)
                    if os.path.exists(candidate):
                        os.environ['PHONEMIZER_ESPEAK_LIBRARY'] = candidate
                        os.environ['PATH'] = f"{path};{os.environ['PATH']}"
                        return True
            bin_path = os.path.join(path, 'espeak-ng.exe')
            if os.path.exists(bin_path):
                os.environ['PATH'] = f"{path};{os.environ['PATH']}"
                break

    print("\nError: espeak-ng not found!")
    print("Install from https://github.com/espeak-ng/espeak-ng/releases")
    return False


if not check_espeak_installed():
    sys.exit(1)

# ---------------------------
# Model initialization (deferred so server can bind to PORT first for Render)
# ---------------------------
tts = None
_tts_lock = threading.Lock()


def get_tts():
    """Load TTS model on first use so the Gradio server can start and bind to PORT immediately."""
    global tts
    with _tts_lock:
        if tts is not None:
            return tts
        import torch
        from neuttsair.neutts import NeuTTSAir
        print("\nLoading TTS model (first use)...")
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
            torch.cuda.synchronize()
            print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB total")
        project_root = os.path.abspath(os.path.dirname(__file__))
        local_backbone = os.path.join(project_root, "Models", "neutts-air")

        def _resolve_hf_snapshot(root_path: str) -> str:
            try:
                for name in os.listdir(root_path):
                    if name.startswith("models--"):
                        models_dir = os.path.join(root_path, name)
                        snapshots_dir = os.path.join(models_dir, "snapshots")
                        if os.path.isdir(snapshots_dir):
                            for snap in os.listdir(snapshots_dir):
                                snap_path = os.path.join(snapshots_dir, snap)
                                if os.path.exists(os.path.join(snap_path, "config.json")):
                                    print(f"Found model in snapshots: {snap_path}")
                                    return snap_path
            except Exception as e:
                print(f"Warning: Error resolving model path: {e}")
            return root_path

        # Use full transformers model (neuphonic/neutts-air) to avoid llama-cpp build on cloud
        backbone_arg = _resolve_hf_snapshot(local_backbone) if os.path.isdir(local_backbone) else "neuphonic/neutts-air"
        print(f"Using backbone: {backbone_arg}")
        print(f"Using codec: neuphonic/neucodec")
        if not torch.cuda.is_available():
            backbone_device = "cpu"
            codec_device = "cpu"
            print("No CUDA GPU detected. Using CPU for backbone and codec.")
        else:
            backbone_device = "cuda"
            codec_device = "cuda"
            gpu_memory_gb = torch.cuda.get_device_properties(0).total_memory / 1024**3
            if gpu_memory_gb <= 4.5:
                print(f"Detected {gpu_memory_gb:.2f} GB GPU. Loading codec on CPU to save GPU memory.")
                codec_device = "cpu"
        tts = NeuTTSAir(
            backbone_repo=backbone_arg,
            backbone_device=backbone_device,
            codec_repo="neuphonic/neucodec",
            codec_device=codec_device,
        )
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
        print("TTS model loaded.")
        return tts

# ---------------------------
# Voice loading logic
# ---------------------------
VOICES = {"samples": {}}
voice_dir = "samples"
os.makedirs(voice_dir, exist_ok=True)

for name in os.listdir(voice_dir):
    if name.endswith(".txt"):
        base = os.path.splitext(name)[0]
        txt_path = os.path.join(voice_dir, f"{base}.txt")
        wav_path = os.path.join(voice_dir, f"{base}.wav")
        pt_path = os.path.join(voice_dir, f"{base}.pt")

        if os.path.exists(txt_path) and (os.path.exists(wav_path) or os.path.exists(pt_path)):
            VOICES["samples"][base] = (txt_path, wav_path if os.path.exists(wav_path) else pt_path)

def format_voice_choice(name):
    return f"Voice: {name}"

# ---------------------------
# Core functions
# ---------------------------
def load_reference(voice_name):
    import torch
    txt_path, audio_or_pt = VOICES["samples"][voice_name]
    ref_text = open(txt_path, "r").read().strip()
    if audio_or_pt.endswith(".pt"):
        ref_codes = torch.load(audio_or_pt)
    else:
        ref_codes = get_tts().encode_reference(audio_or_pt)
    return ref_text, ref_codes


def split_text_into_chunks(text, max_length=150):
    """Split text into smaller chunks preserving sentence and punctuation structure."""
    import re
    
    # Clean up the text first
    text = text.strip()
    if not text:
        return []

    # Split by sentence-ending punctuation while preserving the punctuation
    sentence_pattern = r'([.!?]+)'
    parts = re.split(sentence_pattern, text)

    # Reconstruct sentences with their punctuation
    sentences = []
    i = 0
    while i < len(parts):
        if parts[i].strip():
            sentence = parts[i].strip()
            # Add punctuation if it exists
            if i + 1 < len(parts) and parts[i + 1].strip():
                sentence += parts[i + 1]
                i += 2
            else:
                # If no punctuation follows, add a period (only once)
                if not sentence.endswith(('.', '!', '?')):
                    sentence += '.'
                i += 1
            sentences.append(sentence)
        else:
            i += 1

    # ✅ FIX: Avoid adding the last part twice when no punctuation present
    if len(parts) > 0 and parts[-1].strip():
        last_part = parts[-1].strip()
        # Add only if it's not already included
        if not any(last_part in s or s.startswith(last_part) for s in sentences):
            if not last_part.endswith(('.', '!', '?')):
                last_part += '.'
            sentences.append(last_part)

    # Group sentences into chunks
    chunks = []
    current_chunk = ""

    for sentence in sentences:
        # If single sentence exceeds max_length, split by commas
        if len(sentence) > max_length:
            comma_parts = re.split(r'(,)', sentence)
            temp_sentence = ""
            
            i = 0
            while i < len(comma_parts):
                part = comma_parts[i].strip()
                comma = comma_parts[i + 1] if i + 1 < len(comma_parts) else ''
                
                # If part is still too long, split by words
                if len(part) > max_length:
                    words = part.split()
                    temp_words = []
                    
                    for word in words:
                        test_chunk = ' '.join(temp_words + [word])
                        if len(test_chunk) > max_length and temp_words:
                            if current_chunk:
                                chunks.append(current_chunk.strip())
                                current_chunk = ""
                            chunks.append(' '.join(temp_words))
                            temp_words = [word]
                        else:
                            temp_words.append(word)
                    
                    if temp_words:
                        part = ' '.join(temp_words) + comma
                        if current_chunk and len(current_chunk + ' ' + part) > max_length:
                            chunks.append(current_chunk.strip())
                            current_chunk = part
                        else:
                            current_chunk += (' ' if current_chunk else '') + part
                else:
                    part_with_comma = part + comma
                    if current_chunk and len(current_chunk + ' ' + part_with_comma) > max_length:
                        chunks.append(current_chunk.strip())
                        current_chunk = part_with_comma
                    else:
                        current_chunk += (' ' if current_chunk else '') + part_with_comma
                
                i += 2 if i + 1 < len(comma_parts) else 1
        else:
            # Normal sentence that fits within limit
            if current_chunk and len(current_chunk + ' ' + sentence) > max_length:
                chunks.append(current_chunk.strip())
                current_chunk = sentence
            else:
                current_chunk += (' ' if current_chunk else '') + sentence

    # CRITICAL: Always add remaining chunk at the end
    if current_chunk.strip():
        chunks.append(current_chunk.strip())

    # Filter out empty or duplicate chunks ✅
    final_chunks = []
    for chunk in chunks:
        if chunk.strip() and (not final_chunks or chunk.strip() != final_chunks[-1]):
            final_chunks.append(chunk.strip())

    return final_chunks


def process_chunk(chunk, ref_codes, ref_text, tts_model):
    """Process a single chunk of text and return the audio."""
    try:
        return tts_model.infer(chunk, ref_codes, ref_text)
    except Exception as e:
        # Swallow individual chunk errors and return None to let caller handle it
        return None

def estimate_generation_time(num_chunks):
    """Estimate the generation time based on number of chunks."""
    # Assuming average of 3 seconds per chunk plus overhead
    return num_chunks * 3 + 2

def format_time(seconds):
    """Format seconds into a readable time string."""
    if seconds < 60:
        return f"{seconds:.1f} seconds"
    minutes = int(seconds // 60)
    seconds = seconds % 60
    return f"{minutes} minute{'s' if minutes != 1 else ''} {seconds:.1f} seconds"

def generate_speech(text, voice_name, speed_control="1x"):
    try:
        import time

        # Input validations
        if not text or not text.strip():
            yield 0, None, "❌ Error: Input text cannot be empty.", None
            return

        if not voice_name:
            yield 0, None, "❌ Error: No voice selected. Please select a voice.", None
            return

        if voice_name not in VOICES["samples"]:
            yield 0, None, f"❌ Error: Voice '{voice_name}' not found.", None
            return

        # Convert speed control string to float
        try:
            speed = float(speed_control.rstrip('x'))
        except ValueError:
            speed = 1.0  # Default to 1x if conversion fails

        # Load TTS model on first use (deferred so server can bind to PORT first)
        yield 5, None, "Loading TTS model (first time may take a few minutes)...", None
        try:
            tts_instance = get_tts()
        except Exception as e:
            yield 0, None, f"❌ Failed to load TTS model: {str(e)}", None
            return

        start_time = time.time()
        yield 10, None, "Loading voice reference...", None
        ref_text, ref_codes = load_reference(voice_name)
        
        # Split text into smaller chunks for better processing
        chunks = split_text_into_chunks(text)
        total_chunks = len(chunks)
        
        if total_chunks == 0:
            raise ValueError("No text to process")
        
        # Estimate total time
        estimated_time = estimate_generation_time(total_chunks)
        status = f"Estimated time to completion: {format_time(estimated_time)}\nProcessing {total_chunks} chunks..."
        yield 15, None, status, None
            
        # Process each chunk and store with its index
        chunk_results = []
        for i, chunk in enumerate(chunks, 1):
            chunk_start = time.time()
            
            # Update progress
            progress = int(15 + (75 * i / total_chunks))
            
            # Calculate and show time statistics
            elapsed_time = time.time() - start_time
            if i > 1:
                avg_time_per_chunk = elapsed_time / (i - 1)
                remaining_chunks = total_chunks - (i - 1)
                estimated_remaining = avg_time_per_chunk * remaining_chunks
                status = (
                    f"Processing chunk {i}/{total_chunks}\n"
                    f"Progress: {progress}% complete\n"
                    f"Est. remaining: {format_time(estimated_remaining)}"
                )
            else:
                status = f"Processing chunk {i}/{total_chunks}\nProgress: {progress}% complete"
            
            yield progress, None, status, None
            
            # Generate audio for this chunk
            chunk_wav = process_chunk(chunk, ref_codes, ref_text, tts_instance)
            if chunk_wav is not None:
                # Store chunk with its index to maintain order
                chunk_results.append((i-1, chunk_wav))

        if not chunk_results:
            raise ValueError("Failed to generate any audio")

        # Update status for final processing
        yield 90, None, "Finalizing audio...\nOrdering and combining chunks...", None

        # Sort chunks by their original index and extract the audio data
        chunk_results.sort(key=lambda x: x[0])  # Sort by index
        processed_chunks = [chunk[1] for chunk in chunk_results]  # Extract audio data in order

        # Create silence once
        silence = np.zeros(int(24000 * 0.25))  # 0.25 seconds silence between chunks

        # Concatenate all chunks with silence in between
        all_wav = processed_chunks[0]
        for chunk_wav in processed_chunks[1:]:
            all_wav = np.concatenate([all_wav, silence, chunk_wav])

        # Apply speed adjustment if needed (pitch-preserving time-stretching)
        if speed != 1.0:
            # Use librosa for pitch-preserving time-stretching
            # rate > 1 speeds up, rate < 1 slows down
           all_wav = librosa.effects.time_stretch(all_wav.astype(np.float32), rate=speed)
           
        

        # Save the final audio
        temp_path = "temp_output.wav"
        sf.write(temp_path, all_wav, 24000)
        
        # Calculate and show total time taken
        total_time = time.time() - start_time
        final_status = f"✅ Generation complete!\nTotal time: {format_time(total_time)}"
        
        yield 100, temp_path, final_status, None
    except Exception as e:
        error_status = f"❌ Error generating speech: {str(e)}"
        yield 0, None, error_status, None


def delete_voice(voice_name):
    """Deletes a voice and its associated files."""
    try:
        if voice_name not in VOICES["samples"]:
            return f"❌ Voice '{voice_name}' not found!", gr.update()

        txt_path = f"samples/{voice_name}.txt"
        wav_path = f"samples/{voice_name}.wav"
        pt_path = f"samples/{voice_name}.pt"

        # Remove files if they exist
        for path in [txt_path, wav_path, pt_path]:
            if os.path.exists(path):
                os.remove(path)

        # Remove from VOICES dictionary
        del VOICES["samples"][voice_name]
        
        remaining_voices = list(VOICES["samples"].keys())
        new_selected = remaining_voices[0] if remaining_voices else None
        
        return f"✅ Voice '{voice_name}' deleted successfully!", gr.update(choices=remaining_voices, value=new_selected)
    except Exception as e:
        return f"❌ Error deleting voice: {e}", gr.update()

def clone_voice(new_name, txt, audio_file):
    """Encodes a new reference voice and saves its embedding."""
    try:

        
        # Input validations
        if not new_name or not new_name.strip():
            return "❌ Error: New Voice name cannot be empty.", gr.update()
        
        if not txt or not txt.strip():
            return "❌ Error: Reference text cannot be empty.", gr.update()
            
        if not audio_file:
            return "❌ Error: No reference audio file provided.", gr.update()
            
        if new_name in VOICES["samples"]:
            return f"❌ Error: Voice '{new_name}' already exists. Please choose a different name.", gr.update()

        try:
            tts_instance = get_tts()
        except Exception as e:
            return f"❌ Failed to load TTS model: {str(e)}", gr.update()

        os.makedirs("samples", exist_ok=True)
        txt_path = f"samples/{new_name}.txt"
        wav_path = f"samples/{new_name}.wav"
        pt_path = f"samples/{new_name}.pt"

        # Save reference text and audio
        with open(txt_path, "w") as f:
            f.write(txt.strip())
        shutil.copy(audio_file, wav_path)

        ref_codes = tts_instance.encode_reference(wav_path)
        import torch
        torch.save(ref_codes, pt_path)

        VOICES["samples"][new_name] = (txt_path, pt_path)
        return f"✅ Voice '{new_name}' cloned and saved successfully!", gr.update(choices=list(VOICES["samples"].keys()), value=new_name)
    except Exception as e:
        return f"❌ Error cloning voice: {e}", gr.update()


# ---------------------------
# UI
# ---------------------------
# Custom CSS - consistent dark theme
custom_css = """
footer {display: none !important;}
.footer {display: none !important;}
#api-docs-link {display: none !important;}

/* Dark theme palette */
:root {
    --dark-bg: #1e1e2e;
    --dark-card: #252530;
    --dark-border: #3d3d4a;
    --text-primary: #e4e4e7;
    --text-muted: #a1a1aa;
    --accent: #818cf8;
    --accent-secondary: #a78bfa;
}

/* Modern header - dark gradient */
.heading-container {
    text-align: center;
    padding: 2rem 1rem;
    background: linear-gradient(135deg, #4338ca 0%, #6d28d9 50%, #4c1d95 100%);
    border-radius: 12px;
    margin-bottom: 2rem;
    border: 1px solid var(--dark-border);
    color: white;
}

.heading-container h1 {
    margin: 0;
    font-size: 2.5rem;
    font-weight: 700;
    color: white;
}

.heading-container h3 {
    margin: 0.5rem 0 0 0;
    font-size: 1.1rem;
    font-weight: 400;
    color: rgba(255, 255, 255, 0.9);
}

/* Cards - dark, same as rest of app */
.control-panel {
    background: var(--dark-card) !important;
    padding: 1.5rem;
    border-radius: 12px;
    border: 1px solid var(--dark-border);
    margin-bottom: 1rem;
    color: var(--text-primary) !important;
}

.control-panel label, .control-panel .label-wrap, .control-panel p,
.control-panel h1, .control-panel h2, .control-panel h3, .control-panel h4,
.control-panel span, .control-panel div, .control-panel li, .control-panel small,
.control-panel .markdown, .control-panel [class*="markdown"], .control-panel * {
    color: var(--text-primary) !important;
}

.output-panel {
    background: var(--dark-card) !important;
    padding: 1.5rem;
    border-radius: 12px;
    border: 1px solid var(--dark-border);
    box-shadow: 0 2px 12px rgba(0,0,0,0.3);
    color: var(--text-primary) !important;
}

.output-panel label, .output-panel .label-wrap, .output-panel p,
.output-panel h1, .output-panel h2, .output-panel h3, .output-panel h4,
.output-panel span, .output-panel div, .output-panel li, .output-panel small,
.output-panel .markdown, .output-panel [class*="markdown"], .output-panel * {
    color: var(--text-primary) !important;
}

/* Button styling */
.primary-button {
    width: 100%;
    padding: 0.75rem;
    font-size: 1.1rem;
    font-weight: 600;
    border-radius: 8px;
    margin-top: 1rem;
}

/* Progress bar styling */
.progress-container {
    margin: 1rem 0;
}

/* Status box - dark */
.status-box {
    background: var(--dark-bg) !important;
    border-radius: 8px;
    padding: 1rem;
    min-height: 80px;
    border: 1px solid var(--dark-border);
    color: var(--text-primary) !important;
}

/* Audio container - dark */
.audio-container {
    margin-top: 1rem;
    padding: 1rem;
    background: var(--dark-card) !important;
    border-radius: 8px;
    border: 1px solid var(--dark-border);
    color: var(--text-primary) !important;
}

.audio-container label, .audio-container .label-wrap,
.audio-container h1, .audio-container h2, .audio-container h3, .audio-container h4,
.audio-container span, .audio-container div, .audio-container .markdown,
.audio-container [class*="markdown"], .audio-container * {
    color: var(--text-primary) !important;
}

/* Upload/drop zone text */
.control-panel [class*="upload"] span,
.control-panel [class*="drop"] span,
.output-panel [class*="upload"] span,
.output-panel [class*="drop"] span {
    color: var(--text-muted) !important;
}

.info-text, .info-text * {
    color: var(--text-muted) !important;
}

/* Voice selection styling */
.voice-controls {
    display: flex;
    gap: 0.5rem;
    align-items: flex-end;
}

.tab-nav {
    margin-bottom: 1.5rem;
}

/* Instructions - dark card, same as panels */
.instructions-content {
    background: var(--dark-card) !important;
    padding: 2rem;
    border-radius: 12px;
    border: 1px solid var(--dark-border);
    line-height: 1.8;
    max-width: 1200px;
    margin: 0 auto;
    color: var(--text-primary) !important;
}

.instructions-content p,
.instructions-content li,
.instructions-content span,
.instructions-content div {
    color: var(--text-primary) !important;
}

.instructions-content *:not(h1):not(h2):not(h3) {
    color: var(--text-primary) !important;
}

.instructions-content h1 {
    color: var(--accent) !important;
    border-bottom: 3px solid var(--accent);
    padding-bottom: 0.5rem;
    margin-bottom: 1.5rem;
}

.instructions-content h2 {
    color: var(--accent-secondary) !important;
    margin-top: 2rem;
    margin-bottom: 1rem;
    font-size: 1.5rem;
}

.instructions-content h3 {
    color: #93c5fd !important;
    margin-top: 1.5rem;
    margin-bottom: 0.75rem;
    font-size: 1.2rem;
}

.instructions-content ul, .instructions-content ol {
    margin-left: 1.5rem;
    margin-bottom: 1rem;
}

.instructions-content li {
    margin-bottom: 0.5rem;
    color: var(--text-primary) !important;
}

.instructions-content code {
    background: var(--dark-bg);
    color: var(--accent);
    padding: 0.2rem 0.4rem;
    border-radius: 4px;
    font-family: 'Courier New', monospace;
    font-size: 0.9em;
    border: 1px solid var(--dark-border);
}

.instructions-content hr {
    border: none;
    border-top: 2px solid var(--dark-border);
    margin: 2rem 0;
}

.instructions-content blockquote {
    border-left: 4px solid var(--accent);
    padding-left: 1rem;
    margin-left: 0;
    color: var(--text-muted) !important;
    font-style: italic;
}
"""

with gr.Blocks(title="Virtual Lab Voice Cloning") as app:
    
    # Modern header with gradient
    with gr.Row():
        with gr.Column(scale=1):
            gr.Markdown(
                """
                <div class="heading-container">
                    <h1>🎙️ Virtual Lab Voice Cloning</h1>
                    <h3>High-Quality Text-to-Speech with Voice Cloning</h3>
                </div>
                """,
                elem_classes="heading"
            )

    with gr.Tab("🎯 Generate Speech", elem_classes="tab-nav"):
        with gr.Row(equal_height=True):
            # Left Column - Input Controls
            with gr.Column(scale=1, min_width=400):
                gr.Markdown("### 📝 Input Settings", elem_classes="control-panel")
                
                text_input = gr.Textbox(
                    label="📄 Text to Convert",
                    placeholder="Enter the text you want to convert to speech...",
                    lines=6,
                    elem_classes="text-input"
                )
                
                with gr.Row(elem_classes="voice-controls"):
                    voice_select = gr.Dropdown(
                        label="🎤 Select Voice",
                        choices=list(VOICES["samples"].keys()),
                        value=list(VOICES["samples"].keys())[0] if VOICES["samples"] else None,
                        interactive=True,
                        scale=3
                    )
                    delete_btn = gr.Button(
                        "🗑️",
                        variant="secondary",
                        size="sm",
                        scale=1,
                        min_width=50
                    )
                
                speed_control = gr.Dropdown(
                    label="⚡ Speech Speed",
                    choices=["1x", "1.1x", "1.2x", "1.3x", "1.4x", "1.5x"],
                    value="1x",
                    info="Select playback speed (preserves pitch and voice characteristics)"
                )
                
                generate_btn = gr.Button(
                    "🎙️ Generate Speech",
                    variant="primary",
                    size="lg",
                    elem_classes="primary-button"
                )
            
            # Right Column - Output & Status
            with gr.Column(scale=1, min_width=400):
                gr.Markdown("### 📊 Generation Status", elem_classes="output-panel")
                
                progress_bar = gr.Slider(
                    label="Progress",
                    minimum=0,
                    maximum=100,
                    value=0,
                    interactive=False,
                    elem_classes="progress-container"
                )
                
                status_box = gr.Textbox(
                    label="Status Information",
                    value="Ready to generate speech. Enter text and select a voice.",
                    lines=4,
                    interactive=False,
                    elem_classes="status-box"
                )
                
                delete_status = gr.Textbox(label="Status", visible=False)
                
                gr.Markdown("### 🎵 Audio Output", elem_classes="audio-container")
                audio_output = gr.Audio(
                    label="Generated Audio",
                    autoplay=True
                )

        # Event handlers
        generate_btn.click(
            fn=generate_speech,
            inputs=[text_input, voice_select, speed_control],
            outputs=[progress_bar, audio_output, status_box, delete_status]
        )

        delete_btn.click(
            fn=delete_voice,
            inputs=[voice_select],
            outputs=[delete_status, voice_select]
        )

    with gr.Tab("🧬 Clone New Voice", elem_classes="tab-nav"):
        with gr.Row(equal_height=True):
            # Left Column - Voice Cloning Input
            with gr.Column(scale=1, min_width=400):
                gr.Markdown("### 🎤 Voice Cloning Setup", elem_classes="control-panel")
                
                new_voice_name = gr.Textbox(
                    label="📛 Voice Name",
                    placeholder="Enter a unique name for this voice...",
                    info="Choose a descriptive name for your cloned voice"
                )
                
                ref_text_input = gr.Textbox(
                    label="📝 Reference Text",
                    placeholder="Enter the exact text that is spoken in the audio sample...",
                    lines=4,
                    info="This should match the text spoken in your audio file"
                )
                
                ref_audio_input = gr.Audio(
                    label="🎵 Reference Audio File",
                    type="filepath"
                )
                gr.Markdown(
                    "<small>💡 Upload a WAV file containing the voice sample (recommended: 5-30 seconds)</small>",
                    elem_classes="info-text"
                )
                
                clone_btn = gr.Button(
                    "🧬 Clone Voice",
                    variant="primary",
                    size="lg",
                    elem_classes="primary-button"
                )
            
            # Right Column - Status
            with gr.Column(scale=1, min_width=400):
                gr.Markdown("### 📋 Cloning Status", elem_classes="output-panel")
                
                clone_status = gr.Textbox(
                    label="Status",
                    value="Ready to clone a new voice. Fill in the details on the left and upload an audio sample.",
                    lines=8,
                    interactive=False,
                    elem_classes="status-box"
                )
                
                gr.Markdown(
                    """
                    ### 💡 Tips for Best Results
                    - Use clear, high-quality audio recordings
                    - Ensure the reference text matches what's spoken
                    - Audio length: 5-30 seconds works best
                    - Speak naturally and clearly in the sample
                    - Avoid background noise when possible
                    """,
                    elem_classes="control-panel"
                )

        # Event handler
        clone_btn.click(
            fn=clone_voice,
            inputs=[new_voice_name, ref_text_input, ref_audio_input],
            outputs=[clone_status, voice_select]
        )

    with gr.Tab("📖 Instructions", elem_classes="tab-nav"):
        with gr.Column():
            gr.Markdown(
                """
                # 🎙️ Virtual Lab Voice Cloning - User Guide
                
                Welcome to the Virtual Lab Voice Cloning tool! This guide will help you get started with creating high-quality text-to-speech audio using voice cloning technology.
                
                ---
                
                ## 🎯 How to Generate Speech
                
                ### Step 1: Navigate to the "Generate Speech" Tab
                Click on the **"🎯 Generate Speech"** tab at the top of the interface.
                
                ### Step 2: Enter Your Text
                - Type or paste the text you want to convert to speech in the **"📄 Text to Convert"** text box
                - You can enter multiple sentences or paragraphs
                - The tool will automatically split long texts into manageable chunks
                
                ### Step 3: Select a Voice
                - Choose a voice from the **"🎤 Select Voice"** dropdown menu
                - Only voices that have been cloned and saved will appear in this list
                - You can delete a voice by clicking the 🗑️ button next to the voice selector
                
                ### Step 4: Adjust Speech Speed (Optional)
                - Use the **"⚡ Speech Speed"** dropdown to control playback speed
                - Options range from 1x (normal) to 1.5x (faster)
                - Speed adjustment preserves pitch and voice characteristics
                
                ### Step 5: Generate Audio
                - Click the **"🎙️ Generate Speech"** button
                - Monitor the progress bar and status messages
                - The generated audio will appear automatically when complete
                - You can play the audio directly in the browser or download it
                
                ---
                
                ## 🧬 How to Clone a New Voice
                
                ### Step 1: Navigate to the "Clone New Voice" Tab
                Click on the **"🧬 Clone New Voice"** tab at the top of the interface.
                
                ### Step 2: Prepare Your Audio Sample
                Before cloning, you'll need:
                - A clear audio recording (WAV format recommended)
                - 5-30 seconds of speech works best
                - High-quality audio with minimal background noise
                - Natural, clear speech
                
                ### Step 3: Enter Voice Details
                - **Voice Name**: Enter a unique, descriptive name for your cloned voice
                - **Reference Text**: Type the exact text that is spoken in your audio sample
                - **Reference Audio**: Upload your WAV audio file using the file uploader
                
                ### Step 4: Clone the Voice
                - Click the **"🧬 Clone Voice"** button
                - Wait for the cloning process to complete
                - Once successful, the new voice will be available in the voice selector
                
                ### Step 5: Use Your Cloned Voice
                - Navigate back to the "Generate Speech" tab
                - Your newly cloned voice will appear in the voice dropdown
                - Select it and generate speech as usual
                
                ---
                
                ## 💡 Best Practices & Tips
                
                ### For Voice Cloning:
                - ✅ Use high-quality, clear audio recordings
                - ✅ Ensure the reference text exactly matches what's spoken in the audio
                - ✅ Record in a quiet environment to minimize background noise
                - ✅ Speak naturally and at a normal pace
                - ✅ Use 5-30 seconds of audio for best results
                - ❌ Avoid very short clips (less than 3 seconds)
                - ❌ Avoid clips with heavy background noise or music
                - ❌ Don't use text that doesn't match the audio content
                
                ### For Speech Generation:
                - ✅ Use proper punctuation for better natural pauses
                - ✅ Break long texts into paragraphs for better processing
                - ✅ Review the generated audio and adjust speed if needed
                - ✅ The tool automatically handles long texts by splitting them into chunks
                - ✅ Generated audio is saved and can be downloaded
                
                ### Performance Tips:
                - The tool processes text in chunks for better performance
                - Longer texts will take more time to generate
                - Progress updates show estimated completion time
                - GPU acceleration is used when available for faster processing
                
                ---
                
                ## 🔧 Technical Information
                
                ### Supported Formats:
                - **Input Audio**: WAV format (recommended)
                - **Output Audio**: WAV format, 24kHz sample rate
                - **Text**: Plain text (UTF-8)
                
                ### System Requirements:
                - NVIDIA GPU recommended for best performance
                - CUDA support for GPU acceleration
                - eSpeak NG installed for phonemization
                
                ### Features:
                - High-quality neural text-to-speech
                - Voice cloning from short audio samples
                - Pitch-preserving speed control
                - Automatic text chunking for long inputs
                - Real-time progress tracking
                
                ---
                
                ## ❓ Troubleshooting
                
                ### Common Issues:
                
                **"No voice selected" error:**
                - Make sure you have cloned at least one voice
                - Check that the voice appears in the dropdown menu
                
                **"Input text cannot be empty" error:**
                - Ensure you've entered text in the text input box
                - Check for whitespace-only text
                
                **Audio generation fails:**
                - Verify your GPU has enough memory
                - Try generating shorter texts first
                - Check that the voice files are not corrupted
                
                **Voice cloning fails:**
                - Ensure the audio file is in WAV format
                - Verify the reference text matches the audio content
                - Check that the audio quality is sufficient
                - Make sure the voice name is unique
                
                ---
                
                ## 📝 Notes
                
                - All cloned voices are saved locally in the `samples` folder
                - Generated audio files are temporary and should be downloaded if you want to keep them
                - The tool uses advanced neural networks for high-quality voice synthesis
                - Processing time depends on text length and system performance
                
                ---
                
                **Enjoy creating amazing voice clones! 🎉**
                """,
                elem_classes="instructions-content"
            )

if __name__ == "__main__":
    # Always bind to 0.0.0.0 so Render can detect the port (default PORT=10000)
    port = int(os.environ.get("PORT", "7860"))
    server_name = "0.0.0.0"
    inbrowser = os.environ.get("PORT") is None  # open browser only when not in cloud

    print(f"\nLaunching on http://{server_name}:{port}")
    app.launch(
        server_name=server_name,
        server_port=port,
        share=False,
        inbrowser=inbrowser,
        show_error=True,
        theme=gr.themes.Soft(primary_hue="purple", secondary_hue="blue"),
        css=custom_css,
    )