import gradio as gr
import numpy as np
import tensorflow as tf
from tensorflow import keras
import yfinance as yf
import pandas as pd
from datetime import datetime, timedelta

# Load the model
model = keras.models.load_model('gru_model.h5')

def prepare_data(df):
    """
    Prepare stock data for the model - using percentage changes
    Expected features: Open, High, Low, Close, Volume
    """
    # Select required columns
    features = ['Open', 'High', 'Low', 'Close', 'Volume']
    data = df[features].copy()
    
    # Calculate percentage changes for prices (more stable normalization)
    price_cols = ['Open', 'High', 'Low', 'Close']
    for col in price_cols:
        data[col] = data[col].pct_change().fillna(0)
    
    # Normalize volume using rolling window
    data['Volume'] = (data['Volume'] - data['Volume'].rolling(20, min_periods=1).mean()) / data['Volume'].rolling(20, min_periods=1).std()
    data['Volume'] = data['Volume'].fillna(0)
    
    # Clip extreme values to prevent outliers
    data = data.clip(-3, 3)
    
    return data.values, df['Close'].values

def predict_stock_symbol(symbol, days_to_predict=10):
    """
    Fetch stock data and make prediction with proper price conversion
    """
    try:
        # Clean symbol
        symbol = symbol.strip().upper()
        
        # Fetch stock data (get more than 60 days to ensure we have enough)
        end_date = datetime.now()
        start_date = end_date - timedelta(days=120)  # Get 120 days to be safe
        
        stock = yf.Ticker(symbol)
        df = stock.history(start=start_date, end=end_date)
        
        if df.empty:
            return f"❌ Error: No data found for symbol '{symbol}'. Please check the symbol."
        
        if len(df) < 65:  # Need extra days for percentage change calculation
            return f"❌ Error: Not enough data. Found {len(df)} days, need at least 65 days."
        
        # Prepare data
        normalized_data, close_prices = prepare_data(df)
        
        # Get last 60 days for prediction
        last_60_days = normalized_data[-60:]
        
        # Reshape for model input (1, 60, 5)
        input_data = last_60_days.reshape(1, 60, 5)
        
        # Make prediction
        prediction = model.predict(input_data, verbose=0)
        predicted_values = prediction[0]
        
        # Get context for interpretation
        last_close = close_prices[-1]
        recent_closes = close_prices[-10:]  # Last 10 closes for trend
        avg_recent_change = np.mean(np.diff(recent_closes) / recent_closes[:-1]) * 100
        
        # Interpret predictions as potential future close prices
        # Assume predictions represent relative price movements
        interpreted_prices = []
        current_price = last_close
        
        for i, pred_val in enumerate(predicted_values):
            # Convert normalized prediction to price change
            # Adjust this scaling based on your model's training
            price_change_pct = (pred_val - 1.0) * 5  # Scale factor - adjust as needed
            new_price = current_price * (1 + price_change_pct / 100)
            interpreted_prices.append(new_price)
            current_price = new_price  # Use for next prediction
        
        # Format results
        result = f"📊 **Prediction for {symbol}**\n\n"
        result += f"📈 Current Close Price: **${last_close:.2f}**\n"
        result += f"📊 Recent Trend: {avg_recent_change:+.2f}% avg daily change\n"
        result += f"📅 Data Period: {df.index[0].strftime('%Y-%m-%d')} to {df.index[-1].strftime('%Y-%m-%d')}\n"
        result += f"📊 Total Days Used: {len(df)}\n\n"
        
        result += f"🔮 **Price Predictions (Next 10 periods):**\n"
        for i, (raw_val, price) in enumerate(zip(predicted_values, interpreted_prices), 1):
            change_pct = ((price - last_close) / last_close) * 100
            result += f"  Day {i}: **${price:.2f}** ({change_pct:+.1f}%) [raw: {raw_val:.3f}]\n"
        
        # Summary statistics
        avg_predicted = np.mean(interpreted_prices)
        total_change = ((interpreted_prices[-1] - last_close) / last_close) * 100
        
        result += f"\n📈 **Summary:**\n"
        result += f"• Average Predicted Price: **${avg_predicted:.2f}**\n"
        result += f"• Total 10-Day Change: **{total_change:+.1f}%**\n"
        result += f"• Prediction Range: ${min(interpreted_prices):.2f} - ${max(interpreted_prices):.2f}\n"
        
        result += f"\n⚠️ **Disclaimer:** Model predictions are experimental. Scaling factor may need adjustment based on training data."
        
        return result
        
    except Exception as e:
        return f"❌ Error: {str(e)}"

def get_stock_info(symbol):
    """
    Get basic stock information
    """
    try:
        symbol = symbol.strip().upper()
        stock = yf.Ticker(symbol)
        info = stock.info
        
        name = info.get('longName', 'N/A')
        sector = info.get('sector', 'N/A')
        country = info.get('country', 'N/A')
        
        return f"📋 **Stock Info:**\n• Name: {name}\n• Sector: {sector}\n• Country: {country}"
        
    except:
        return "ℹ️ Stock info not available"

# Create Gradio interface
with gr.Blocks(title="Stock Symbol GRU Predictor", theme=gr.themes.Soft()) as demo:
    gr.Markdown("# 📈 Stock Symbol GRU Predictor")
    gr.Markdown("Enter a stock symbol to fetch historical data and get GRU model predictions.")
    
    with gr.Row():
        with gr.Column(scale=2):
            symbol_input = gr.Textbox(
                label="Stock Symbol",
                placeholder="e.g., AAPL, RNO.PA, TSLA, MSFT",
                value="RNO.PA"
            )
            
            predict_btn = gr.Button("🔮 Predict", variant="primary", size="lg")
            
            info_btn = gr.Button("ℹ️ Get Stock Info", variant="secondary")
        
        with gr.Column(scale=3):
            output = gr.Textbox(
                label="Prediction Results",
                lines=15,
                max_lines=20
            )
            
            info_output = gr.Textbox(
                label="Stock Information",
                lines=4
            )
    
    # Event handlers
    predict_btn.click(predict_stock_symbol, inputs=symbol_input, outputs=output)
    info_btn.click(get_stock_info, inputs=symbol_input, outputs=info_output)
    
    # Example symbols
    gr.Markdown("""
    ### 📋 Example Symbols:
    • **US Stocks**: AAPL, MSFT, GOOGL, TSLA, AMZN
    • **European**: RNO.PA (Renault), AIR.PA (Airbus), SAP (SAP SE)
    • **Indices**: ^GSPC (S&P 500), ^IXIC (NASDAQ)
    
    ### 🔧 How it works:
    1. Fetches last 90 days of stock data
    2. Uses last 60 days as model input
    3. Normalizes data (prices relative to first close, volume min-max)
    4. Generates 10 prediction values using your GRU model
    
    ### ⚠️ Disclaimer:
    This is for educational purposes only. Not financial advice.
    """)

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