# ✅ Stock Recommendation Extractor from YouTube Audio (with full error reporting)

import os
import gradio as gr
import tempfile
import shutil
import re
import traceback
from yt_dlp import YoutubeDL

# Optional: use OpenAI Whisper if available
try:
    import whisper
    WHISPER_AVAILABLE = True
except:
    WHISPER_AVAILABLE = False

# ✅ Download audio using working logic

def download_audio(url, cookies_path=None):
    try:
        temp_dir = tempfile.mkdtemp()
        output_path = os.path.join(temp_dir, "audio")

        ydl_opts = {
            'format': 'bestaudio[ext=m4a]/bestaudio/best',
            'outtmpl': output_path + '.%(ext)s',
            'quiet': True,
            'noplaylist': True,
            'cookiefile': cookies_path if cookies_path else None,
            'user_agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
            'referer': 'https://www.youtube.com/',
            'force_ipv4': True,
            'http_headers': {
                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)',
                'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
                'Accept-Language': 'en-US,en;q=0.5',
                'Referer': 'https://www.youtube.com/'
            },
        }

        with YoutubeDL(ydl_opts) as ydl:
            ydl.download([url])

        for ext in [".m4a", ".webm", ".mp3"]:
            final_path = output_path + ext
            if os.path.exists(final_path):
                return final_path, "✅ Audio downloaded successfully"

        return None, "❌ Audio file not found"

    except Exception as e:
        traceback.print_exc()
        return None, f"❌ Download error: {str(e)}"

# ✅ Transcribe audio using Whisper

def transcribe_audio(path):
    if not WHISPER_AVAILABLE:
        return "❌ Whisper not available. Please install openai-whisper."
    try:
        model = whisper.load_model("tiny")
        result = model.transcribe(path)
        return result["text"]
    except Exception as e:
        traceback.print_exc()
        return f"❌ Transcription failed: {str(e)}"

# ✅ Extract stock-related information from transcript

def extract_stock_info(text):
    try:
        companies = re.findall(r'\b[A-Z][a-z]+(?: [A-Z][a-z]+)*\b', text)
        symbols = re.findall(r'\b[A-Z]{2,5}\b', text)
        prices = re.findall(r'\$\d+(?:\.\d{1,2})?', text)
        actions = re.findall(r'\b(buy|sell|hold|target|bullish|bearish|stop loss)\b', text, re.IGNORECASE)

        result = "=== STOCK RECOMMENDATION ANALYSIS ===\n\n"
        if companies:
            result += f"🏢 Companies Mentioned: {', '.join(set(companies[:10]))}\n"
        if symbols:
            result += f"🔠 Symbols: {', '.join(set(symbols[:10]))}\n"
        if prices:
            result += f"💲 Prices: {', '.join(set(prices[:10]))}\n"
        if actions:
            result += f"📊 Actions: {', '.join(set(actions[:10]))}\n"

        # Highlight potential recommendations
        recommendations = []
        for line in text.split("."):
            if any(word in line.lower() for word in ['buy', 'sell', 'target', 'hold']):
                recommendations.append(line.strip())

        if recommendations:
            result += "\n🎯 Potential Recommendations:\n"
            for r in recommendations[:5]:
                result += f"• {r}\n"

        if not any([companies, symbols, prices, actions]):
            result += "\n⚠️ No stock-related insights detected."

        return result

    except Exception as e:
        return f"❌ Stock info extraction failed: {str(e)}"

# ✅ Save uploaded cookies.txt

def save_cookies(file):
    if file is None:
        return None

    temp_path = tempfile.mktemp(suffix=".txt")

    try:
        # Handle both file-like object and NamedString
        if hasattr(file, "read"):  # File-like
            with open(temp_path, "wb") as f:
                f.write(file.read())
        else:  # NamedString (str path)
            shutil.copy(file, temp_path)

        return temp_path

    except Exception as e:
        print(f"❌ Failed to handle cookies.txt: {e}")
        return None


# ✅ Full pipeline with error traceback

def run_pipeline(url, cookies_file):
    try:
        if not WHISPER_AVAILABLE:
            return "❌ Whisper is not installed. Run: pip install openai-whisper", ""
        if not url:
            return "❌ YouTube URL required", ""

        cookie_path = save_cookies(cookies_file)
        audio_path, status = download_audio(url, cookie_path)
        if not audio_path:
            return status, ""

        transcript = transcribe_audio(audio_path)
        if transcript.startswith("❌"):
            return transcript, ""

        stock_info = extract_stock_info(transcript)
        return "✅ Complete", stock_info

    except Exception as e:
        tb = traceback.format_exc()
        print(tb)
        return f"❌ Unhandled Error:\n{tb}", ""

# ✅ Gradio Interface
with gr.Blocks(title="Stock Insights from YouTube Audio") as demo:
    gr.Markdown("""
    # 🎧 Extract Stock Recommendations from YouTube Audio
    This app downloads the audio from a YouTube video, transcribes it with Whisper,
    and extracts stock trading recommendations, sentiments, and symbols.
    """)

    with gr.Row():
        url_input = gr.Textbox(label="🎥 YouTube Video URL")
        cookie_input = gr.File(label="cookies.txt (optional)", file_types=[".txt"])

    run_btn = gr.Button("🚀 Extract Stock Info")
    status_output = gr.Textbox(label="Status")
    result_output = gr.Textbox(label="Stock Info", lines=12)

    run_btn.click(fn=run_pipeline, inputs=[url_input, cookie_input], outputs=[status_output, result_output])

if __name__ == "__main__":
    demo.launch(debug=True)