#!/usr/bin/env python3
"""
Genesis TTS Generator
=====================
Integrates Gemini Native TTS (Speech Generation) for audio capabilities.

Features:
- Text-to-speech generation
- Support for multiple voices/styles
- Control over pace and tone
- Cost tracking

Usage:
    from tts_generator import TTSAgent
    agent = TTSAgent()
    result = agent.generate("Hello, I am Genesis.")
"""

import os
import sys
import json
import base64
from datetime import datetime
from pathlib import Path
from typing import Optional, Dict, Any, List

# Add genesis-system to path
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))

from google import genai
from google.genai import types
from budget_manager import BudgetManager

# Load config
CONFIG_PATH = os.path.join(os.path.dirname(__file__), "genesis_config.json")
with open(CONFIG_PATH) as f:
    CONFIG = json.load(f)

# Pricing (Estimated for Gemini TTS)
TTS_COST_PER_1K_CHARS = 0.02  # $0.02 per 1000 characters (placeholder)

# Output directory
OUTPUT_DIR = Path(os.path.dirname(__file__)) / "generated_audio"
OUTPUT_DIR.mkdir(exist_ok=True)


class TTSAgent:
    """
    Agent for generating speech using Gemini native TTS.
    Allows for stylistic control via prompts.
    """
    
    def __init__(self, 
                 model: str = "gemini-2.5-flash-tts-preview",
                 budget_limit: float = 10.0):
        self.model_name = model
        self.budget = BudgetManager(daily_limit=budget_limit)
        
        # Configure API
        api_key = CONFIG["gemini"]["api_key"]
        self.client = genai.Client(api_key=api_key)
        
        print(f"[OK] TTS Agent initialized")
        print(f"[OK] Model: {model}")
        print(f"[OK] Base Cost: ${TTS_COST_PER_1K_CHARS}/1K chars")
    
    def generate(self,
                 text: str,
                 voice_style: str = "professional, clear, helpful",
                 save_to_disk: bool = True) -> Dict[str, Any]:
        """
        Generate audio from text.
        
        Args:
            text: Text to convert to speech
            voice_style: Description of the voice characteristics
            save_to_disk: Save locally
            
        Returns:
            Dict with 'audio_data', 'path', 'cost', 'timestamp'
        """
        # Budget check (0.02 per 1k chars)
        cost = (len(text) / 1000) * TTS_COST_PER_1K_CHARS
        if cost < 0.01: cost = 0.01 # Minimum charge
        
        if not self.budget.is_within_budget():
            return {
                "error": "budget_exceeded",
                "status": "failed"
            }
        
        try:
            # Generate speech
            # Note: Exact SDK method for native TTS might vary in early preview
            # Some SDKs use client.models.generate_content with specific output format
            # or a dedicated client.models.generate_speech.
            
            response = self.client.models.generate_speech(
                model=self.model_name,
                text=text,
                config=types.GenerateSpeechConfig(
                    voice_style=voice_style
                )
            )
            
            audio_bytes = response.audio.audio_bytes
            
            # Log cost
            self.budget.log_cost(cost, self.model_name)
            
            # Save to disk
            path = None
            if save_to_disk:
                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                filename = f"tts_{timestamp}.mp3"
                filepath = OUTPUT_DIR / filename
                
                with open(filepath, "wb") as f:
                    f.write(audio_bytes)
                
                path = str(filepath)
                print(f"[SAVED] {filepath}")
            
            return {
                "audio_base64": base64.b64encode(audio_bytes).decode(),
                "path": path,
                "cost": cost,
                "text": text,
                "timestamp": datetime.now().isoformat()
            }
            
        except Exception as e:
            # Fallback debug message if method is slightly different
            return {
                "error": str(e),
                "debug": "Ensure Gemini native TTS model is available in your region.",
                "status": "failed"
            }

    def get_stats(self) -> Dict[str, Any]:
        """Get agent statistics."""
        return {
            "model": self.model_name,
            "budget_spent": self.budget.get_current_spend(),
            "budget_limit": self.budget.daily_limit,
            "within_budget": self.budget.is_within_budget(),
            "output_dir": str(OUTPUT_DIR)
        }


# CLI for testing
if __name__ == "__main__":
    import argparse
    
    parser = argparse.ArgumentParser(description="TTS Generator")
    parser.add_argument("--speak", "-s", type=str, help="Convert text to speech")
    parser.add_argument("--style", type=str, default="professional, clear, helpful", help="Voice style")
    parser.add_argument("--test", action="store_true", help="Run self-test")
    args = parser.parse_args()
    
    # Use a standard model if preview isn't found
    agent = TTSAgent()
    
    if args.test:
        print("\n[TEST] TTS Generator Self-Test")
        print(f"[OK] Agent initialized: {agent.get_stats()}")
        print("\n[DONE] Self-test complete")
        
    elif args.speak:
        result = agent.generate(args.speak, voice_style=args.style)
        if result.get("error"):
            print(f"[ERROR] {result['error']}")
            if result.get("debug"): print(f"[DEBUG] {result['debug']}")
        else:
            print(f"[OK] Audio generated: {result['path']}")
            print(f"[COST] ${result['cost']:.4f}")
    else:
        print("Usage: python tts_generator.py --speak 'your message'")
        print("       python tts_generator.py --test")