'''

import altair as alt
import numpy as np
import pandas as pd
import streamlit as st

"""
# Welcome to Streamlit!

Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
forums](https://discuss.streamlit.io).

In the meantime, below is an example of what you can do with just a few lines of code:
"""

num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
num_turns = st.slider("Number of turns in spiral", 1, 300, 31)

indices = np.linspace(0, 1, num_points)
theta = 2 * np.pi * num_turns * indices
radius = indices

x = radius * np.cos(theta)
y = radius * np.sin(theta)

df = pd.DataFrame({
    "x": x,
    "y": y,
    "idx": indices,
    "rand": np.random.randn(num_points),
})

st.altair_chart(alt.Chart(df, height=700, width=700)
    .mark_point(filled=True)
    .encode(
        x=alt.X("x", axis=None),
        y=alt.Y("y", axis=None),
        color=alt.Color("idx", legend=None, scale=alt.Scale()),
        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
    ))




import streamlit as st
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import torch.nn.functional as F
import os
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from datetime import datetime
import re

# Page configuration
st.set_page_config(
    page_title="FinBERT Sentiment Analyzer",
    page_icon="💰",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom CSS for better styling
st.markdown("""
<style>
    .main-header {
        text-align: center;
        color: #1f77b4;
        margin-bottom: 2rem;
    }
    .sentiment-card {
        padding: 1rem;
        border-radius: 10px;
        margin: 0.5rem 0;
        text-align: center;
    }
    .negative { background-color: #ffebee; border-left: 5px solid #f44336; }
    .neutral { background-color: #f3e5f5; border-left: 5px solid #9c27b0; }
    .positive { background-color: #e8f5e8; border-left: 5px solid #4caf50; }
    .metric-container {
        background-color: #f8f9fa;
        padding: 1rem;
        border-radius: 10px;
        margin: 1rem 0;
    }
</style>
""", unsafe_allow_html=True)

st.markdown('<h1 class="main-header">💰 FinBERT: Financial Sentiment Analysis</h1>', unsafe_allow_html=True)

# Sidebar
with st.sidebar:
    st.header("ℹ️ About")
    st.markdown("""
    **Model:** `yiyanghkust/finbert-tone`  
    Trained specifically on financial texts for accurate sentiment analysis of:
    - Financial news
    - Earnings reports  
    - Market analysis
    - Investment research
    """)
    
    st.header("⚙️ Settings")
    confidence_threshold = st.slider("Confidence Threshold", 0.0, 1.0, 0.5, help="Minimum confidence for sentiment classification")
    show_probabilities = st.checkbox("Show All Probabilities", value=True)
    batch_analysis = st.checkbox("Enable Batch Analysis", help="Analyze multiple texts at once")

@st.cache_resource(show_spinner=False)
def load_model():
    """Load FinBERT model and tokenizer with error handling"""
    try:
        cache_dir = "/tmp/huggingface"
        os.makedirs(cache_dir, exist_ok=True)
        
        with st.spinner("Loading FinBERT model... This may take a moment."):
            tokenizer = AutoTokenizer.from_pretrained(
                "yiyanghkust/finbert-tone", 
                cache_dir=cache_dir
            )
            model = AutoModelForSequenceClassification.from_pretrained(
                "yiyanghkust/finbert-tone", 
                cache_dir=cache_dir
            )
        return tokenizer, model, None
    except Exception as e:
        return None, None, str(e)

def analyze_sentiment(text, tokenizer, model):
    """Analyze sentiment with error handling and additional metrics"""
    try:
        # Preprocess text
        text = re.sub(r'\s+', ' ', text.strip())
        
        inputs = tokenizer(
            text, 
            return_tensors="pt", 
            truncation=True, 
            padding=True,
            max_length=512
        )
        
        with torch.no_grad():
            outputs = model(**inputs)
            probs = F.softmax(outputs.logits, dim=1).squeeze()
        
        labels = ["Negative", "Neutral", "Positive"]
        sentiment_scores = {label: prob.item() for label, prob in zip(labels, probs)}
        
        # Determine primary sentiment
        max_prob = max(sentiment_scores.values())
        primary_sentiment = max(sentiment_scores, key=sentiment_scores.get)
        
        return sentiment_scores, primary_sentiment, max_prob, None
    except Exception as e:
        return None, None, None, str(e)

def create_sentiment_chart(sentiment_scores):
    """Create an interactive sentiment visualization"""
    labels = list(sentiment_scores.keys())
    values = list(sentiment_scores.values())
    colors = ['#f44336', '#9c27b0', '#4caf50']
    
    fig = go.Figure(data=[
        go.Bar(
            x=labels,
            y=values,
            marker_color=colors,
            text=[f'{v:.3f}' for v in values],
            textposition='auto',
        )
    ])
    
    fig.update_layout(
        title="Sentiment Analysis Results",
        xaxis_title="Sentiment",
        yaxis_title="Confidence Score",
        yaxis=dict(range=[0, 1]),
        height=400,
        showlegend=False
    )
    
    return fig

# Load model
tokenizer, model, error = load_model()

if error:
    st.error(f"Failed to load model: {error}")
    st.stop()

if tokenizer and model:
    st.success("✅ FinBERT model loaded successfully!")
    
    # Main analysis interface
    if not batch_analysis:
        st.header("📝 Single Text Analysis")
        text = st.text_area(
            "Enter financial news, report, or analysis:",
            height=150,
            placeholder="Example: The company reported strong quarterly earnings with revenue growth of 15% year-over-year..."
        )
        
        col1, col2, col3 = st.columns([1, 1, 2])
        with col1:
            analyze_button = st.button("🔍 Analyze Sentiment", type="primary")
        with col2:
            clear_button = st.button("🗑️ Clear")
        
        if clear_button:
            st.rerun()
        
        if analyze_button and text.strip():
            with st.spinner("Analyzing sentiment..."):
                sentiment_scores, primary_sentiment, confidence, error = analyze_sentiment(text, tokenizer, model)
            
            if error:
                st.error(f"Analysis failed: {error}")
            else:
                # Results section
                st.header("📊 Analysis Results")
                
                # Primary sentiment with confidence
                col1, col2, col3 = st.columns(3)
                
                sentiment_emojis = {"Negative": "📉", "Neutral": "😐", "Positive": "📈"}
                sentiment_colors = {"Negative": "red", "Neutral": "gray", "Positive": "green"}
                
                with col1:
                    st.metric(
                        "Primary Sentiment",
                        f"{sentiment_emojis[primary_sentiment]} {primary_sentiment}",
                        delta=f"{confidence:.1%} confidence"
                    )
                
                with col2:
                    st.metric(
                        "Text Length",
                        f"{len(text)} characters",
                        delta=f"{len(text.split())} words"
                    )
                
                with col3:
                    reliability = "High" if confidence > 0.7 else "Medium" if confidence > 0.5 else "Low"
                    st.metric("Reliability", reliability)
                
                # Detailed probabilities
                if show_probabilities:
                    st.subheader("Detailed Sentiment Scores")
                    
                    for sentiment, score in sentiment_scores.items():
                        emoji = sentiment_emojis[sentiment]
                        color = "negative" if sentiment == "Negative" else "neutral" if sentiment == "Neutral" else "positive"
                        
                        st.markdown(f"""
                        <div class="sentiment-card {color}">
                            <h4>{emoji} {sentiment}</h4>
                            <h2>{score:.3f}</h2>
                            <div style="width: 100%; background-color: #ddd; border-radius: 25px;">
                                <div style="width: {score*100}%; height: 10px; background-color: {sentiment_colors[sentiment]}; border-radius: 25px;"></div>
                            </div>
                        </div>
                        """, unsafe_allow_html=True)
                
                # Visualization
                st.subheader("📈 Sentiment Visualization")
                fig = create_sentiment_chart(sentiment_scores)
                st.plotly_chart(fig, use_container_width=True)
    
    else:
        # Batch analysis mode
        st.header("📊 Batch Analysis")
        
        # Option to upload file or enter multiple texts
        analysis_method = st.radio(
            "Choose analysis method:",
            ["Enter multiple texts", "Upload CSV file"]
        )
        
        if analysis_method == "Enter multiple texts":
            texts_input = st.text_area(
                "Enter multiple texts (one per line):",
                height=200,
                placeholder="Text 1: Company reports strong earnings...\nText 2: Market volatility increases...\nText 3: New regulations impact sector..."
            )
            
            if st.button("🔍 Analyze All Texts") and texts_input.strip():
                texts = [text.strip() for text in texts_input.split('\n') if text.strip()]
                
                if texts:
                    results = []
                    progress_bar = st.progress(0)
                    
                    for i, text in enumerate(texts):
                        sentiment_scores, primary_sentiment, confidence, error = analyze_sentiment(text, tokenizer, model)
                        
                        if not error:
                            results.append({
                                'Text': text[:100] + '...' if len(text) > 100 else text,
                                'Primary Sentiment': primary_sentiment,
                                'Confidence': confidence,
                                'Negative': sentiment_scores['Negative'],
                                'Neutral': sentiment_scores['Neutral'],
                                'Positive': sentiment_scores['Positive']
                            })
                        
                        progress_bar.progress((i + 1) / len(texts))
                    
                    if results:
                        df = pd.DataFrame(results)
                        
                        # Summary statistics
                        st.subheader("📈 Batch Analysis Summary")
                        col1, col2, col3 = st.columns(3)
                        
                        with col1:
                            positive_count = len(df[df['Primary Sentiment'] == 'Positive'])
                            st.metric("Positive Texts", positive_count, f"{positive_count/len(df)*100:.1f}%")
                        
                        with col2:
                            neutral_count = len(df[df['Primary Sentiment'] == 'Neutral'])
                            st.metric("Neutral Texts", neutral_count, f"{neutral_count/len(df)*100:.1f}%")
                        
                        with col3:
                            negative_count = len(df[df['Primary Sentiment'] == 'Negative'])
                            st.metric("Negative Texts", negative_count, f"{negative_count/len(df)*100:.1f}%")
                        
                        # Results table
                        st.subheader("📋 Detailed Results")
                        st.dataframe(df, use_container_width=True)
                        
                        # Download results
                        csv = df.to_csv(index=False)
                        st.download_button(
                            "📥 Download Results (CSV)",
                            csv,
                            f"sentiment_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
                            "text/csv"
                        )
        
        elif analysis_method == "Upload CSV file":
            uploaded_file = st.file_uploader(
                "Choose a CSV file with a 'text' column",
                type=['csv']
            )
            
            if uploaded_file is not None:
                try:
                    df = pd.read_csv(uploaded_file)
                    
                    if 'text' not in df.columns:
                        st.error("CSV file must contain a 'text' column")
                    else:
                        st.write(f"Loaded {len(df)} texts from CSV file")
                        st.dataframe(df.head(), use_container_width=True)
                        
                        if st.button("🔍 Analyze CSV Data"):
                            results = []
                            progress_bar = st.progress(0)
                            
                            for i, row in df.iterrows():
                                text = str(row['text'])
                                sentiment_scores, primary_sentiment, confidence, error = analyze_sentiment(text, tokenizer, model)
                                
                                if not error:
                                    result_row = row.to_dict()
                                    result_row.update({
                                        'Primary Sentiment': primary_sentiment,
                                        'Confidence': confidence,
                                        'Negative Score': sentiment_scores['Negative'],
                                        'Neutral Score': sentiment_scores['Neutral'],
                                        'Positive Score': sentiment_scores['Positive']
                                    })
                                    results.append(result_row)
                                
                                progress_bar.progress((i + 1) / len(df))
                            
                            if results:
                                results_df = pd.DataFrame(results)
                                
                                # Display results
                                st.subheader("📋 Analysis Results")
                                st.dataframe(results_df, use_container_width=True)
                                
                                # Download enhanced results
                                csv = results_df.to_csv(index=False)
                                st.download_button(
                                    "📥 Download Enhanced Results (CSV)",
                                    csv,
                                    f"enhanced_sentiment_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
                                    "text/csv"
                                )
                
                except Exception as e:
                    st.error(f"Error processing CSV file: {str(e)}")

# Footer
st.markdown("---")
st.markdown("""
<div style='text-align: center; color: #666; margin-top: 2rem;'>
    <p>💡 <strong>Tip:</strong> For best results, use complete sentences and financial context</p>
    <p>Built with Streamlit • Powered by FinBERT</p>
</div>
""", unsafe_allow_html=True)







import streamlit as st
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
import torch.nn.functional as F
import os

st.set_page_config(page_title="💰 FinBERT: Financial Sentiment Analysis", layout="centered")
st.title("💰 FinBERT: Financial Sentiment Analysis")
st.markdown("Модель: `yiyanghkust/finbert-tone` — обучена на финансовых текстах")

@st.cache_resource
def load_model():
    # Установка кастомного пути к кэшу
    cache_dir = "/tmp/huggingface"
    os.makedirs(cache_dir, exist_ok=True)

    tokenizer = AutoTokenizer.from_pretrained("yiyanghkust/finbert-tone", cache_dir=cache_dir)
    model = AutoModelForSequenceClassification.from_pretrained("yiyanghkust/finbert-tone", cache_dir=cache_dir)
    return tokenizer, model

tokenizer, model = load_model()

text = st.text_area("Введите финансовую новость или отчёт:", height=150)

if st.button("Анализировать тональность") and text.strip():
    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
    with torch.no_grad():
        outputs = model(**inputs)
        probs = F.softmax(outputs.logits, dim=1).squeeze()

    labels = ["📉 Negative", "😐 Neutral", "📈 Positive"]
    for label, prob in zip(labels, probs):
        st.write(f"**{label}:** {prob.item():.3f}")

'''


import time
import os
from datetime import datetime, timedelta
import re

import yfinance as yf
import streamlit as st
from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
import torch
import torch.nn.functional as F
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import numpy as np
from textblob import TextBlob
import requests
from bs4 import BeautifulSoup


# Page configuration
st.set_page_config(
    page_title="Financial News Sentiment Analyzer",
    page_icon="📈",
    layout="wide",
    initial_sidebar_state="expanded"
)

# Custom CSS for financial theme
st.markdown("""
<style>
    .main-header {
        text-align: center;
        background: linear-gradient(90deg, #1f4e79, #2e7d32);
        color: white;
        padding: 1rem;
        border-radius: 15px;
        margin-bottom: 2rem;
    }
    .metric-card {
        background: white;
        padding: 1.5rem;
        border-radius: 10px;
        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
        border-left: 4px solid #1f4e79;
        margin: 1rem 0;
    }
    .bullish { border-left-color: #4caf50 !important; }
    .bearish { border-left-color: #f44336 !important; }
    .neutral { border-left-color: #ff9800 !important; }
    .market-impact {
        padding: 1rem;
        border-radius: 8px;
        margin: 0.5rem 0;
        font-weight: bold;
    }
    .high-impact { background-color: #ffebee; color: #c62828; }
    .medium-impact { background-color: #fff3e0; color: #ef6c00; }
    .low-impact { background-color: #e8f5e8; color: #2e7d32; }
    .trading-signal {
        padding: 1rem;
        border-radius: 10px;
        text-align: center;
        font-size: 1.2rem;
        font-weight: bold;
        margin: 1rem 0;
    }
    .buy-signal { background: linear-gradient(135deg, #4caf50, #66bb6a); color: white; }
    .sell-signal { background: linear-gradient(135deg, #f44336, #ef5350); color: white; }
    .hold-signal { background: linear-gradient(135deg, #ff9800, #ffa726); color: white; }
    .risk-indicator {
        display: inline-block;
        padding: 0.3rem 0.8rem;
        border-radius: 20px;
        font-size: 0.9rem;
        font-weight: bold;
        margin: 0.2rem;
    }
    .risk-low { background-color: #4caf50; color: white; }
    .risk-medium { background-color: #ff9800; color: white; }
    .risk-high { background-color: #f44336; color: white; }
</style>
""", unsafe_allow_html=True)

st.markdown('<div class="main-header"><h1>📈 Financial News Sentiment Analysis Platform</h1><p>AI-Powered Market Intelligence & Trading Insights</p></div>', unsafe_allow_html=True)

# Sidebar configuration
with st.sidebar:
    st.header("🎯 Analysis Configuration")
    
    analysis_type = st.selectbox(
        "Analysis Type:",
        ["Single News Analysis", "Portfolio Impact Analysis", "Market Sector Analysis", "Real-time News Feed"]
    )
    
    st.header("📊 Financial Models")
    model_choice = st.selectbox(
        "Sentiment Model:",
        ["FinBERT (Financial)", "RoBERTa (General)", "Custom Ensemble"]
    )
    
    st.header("⚙️ Trading Parameters")
    risk_tolerance = st.selectbox("Risk Tolerance:", ["Conservative", "Moderate", "Aggressive"])
    investment_horizon = st.selectbox("Investment Horizon:", ["Day Trading", "Swing (1-7 days)", "Position (1-3 months)", "Long-term (6+ months)"])
    position_size = st.slider("Position Size ($)", 1000, 100000, 10000, 1000)
    
    st.header("🎛️ Alert Settings")
    sentiment_threshold = st.slider("Sentiment Alert Threshold", 0.0, 1.0, 0.7)
    enable_notifications = st.checkbox("Enable Trading Alerts")

@st.cache_resource
def load_financial_models():
    """Load multiple financial sentiment models"""
    try:
        cache_dir = "/tmp/huggingface"
        os.makedirs(cache_dir, exist_ok=True)
        
        # FinBERT for financial sentiment
        finbert_tokenizer = AutoTokenizer.from_pretrained("yiyanghkust/finbert-tone", cache_dir=cache_dir)
        finbert_model = AutoModelForSequenceClassification.from_pretrained("yiyanghkust/finbert-tone", cache_dir=cache_dir)
        
        # Financial NER for entity extraction
        #ner_pipeline = pipeline("ner", model="elastic/distilbert-base-cased-finetuned-conll03-english", aggregation_strategy="simple", cache_dir=cache_dir)
        
        # Load Financial NER model and tokenizer explicitly
        ner_tokenizer = AutoTokenizer.from_pretrained(
            "elastic/distilbert-base-cased-finetuned-conll03-english", cache_dir=cache_dir
        )
        ner_model = AutoModelForTokenClassification.from_pretrained(
            "elastic/distilbert-base-cased-finetuned-conll03-english", cache_dir=cache_dir
        )

        # Then create pipeline using objects
        ner_pipeline = pipeline(
            "ner",
            model=ner_model,
            tokenizer=ner_tokenizer,
            aggregation_strategy="simple",
        )
        
        return finbert_tokenizer, finbert_model, ner_pipeline, None
    except Exception as e:
        return None, None, None, str(e)

def extract_financial_entities(text, ner_pipeline):
    """Extract companies, stocks, and financial entities from text"""
    try:
        entities = ner_pipeline(text)
        
        # Common financial terms and patterns
        financial_patterns = {
            'stocks': r'\b([A-Z]{1,5})\b(?=\s*(?:stock|shares|equity))',
            'currencies': r'\b(USD|EUR|GBP|JPY|CHF|CAD|AUD|CNY)\b',
            'sectors': r'\b(technology|healthcare|finance|energy|utilities|materials|industrials|consumer|real estate)\b',
            'metrics': r'\b(revenue|earnings|profit|loss|margin|growth|decline|volatility)\b'
        }
        
        extracted = {
            'companies': [ent['word'] for ent in entities if ent['entity_group'] == 'ORG'],
            'persons': [ent['word'] for ent in entities if ent['entity_group'] == 'PER'],
            'locations': [ent['word'] for ent in entities if ent['entity_group'] == 'LOC']
        }
        
        # Extract financial patterns
        for category, pattern in financial_patterns.items():
            matches = re.findall(pattern, text, re.IGNORECASE)
            extracted[category] = matches
        
        return extracted
    except:
        return {}

def analyze_financial_sentiment(text, tokenizer, model):
    """Comprehensive financial sentiment analysis"""
    try:
        # Basic sentiment analysis
        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=512)
        
        with torch.no_grad():
            outputs = model(**inputs)
            probs = F.softmax(outputs.logits, dim=1).squeeze()
        
        sentiment_scores = {
            'bearish': probs[0].item(),
            'neutral': probs[1].item(), 
            'bullish': probs[2].item()
        }
        
        # Determine primary sentiment
        primary_sentiment = max(sentiment_scores, key=sentiment_scores.get)
        confidence = max(sentiment_scores.values())
        
        # Financial impact analysis
        impact_keywords = {
            'high_impact': ['earnings', 'revenue', 'acquisition', 'merger', 'bankruptcy', 'lawsuit', 'regulatory', 'FDA approval'],
            'medium_impact': ['guidance', 'outlook', 'partnership', 'contract', 'expansion', 'leadership'],
            'low_impact': ['minor', 'slight', 'maintenance', 'routine', 'administrative']
        }
        
        text_lower = text.lower()
        impact_level = 'low'
        
        for level, keywords in impact_keywords.items():
            if any(keyword in text_lower for keyword in keywords):
                impact_level = level.replace('_impact', '')
                break
        
        # Market volatility prediction
        volatility_indicators = ['volatile', 'uncertain', 'fluctuation', 'swing', 'dramatic', 'sudden']
        volatility_score = sum(1 for indicator in volatility_indicators if indicator in text_lower) / len(volatility_indicators)
        
        # Risk assessment
        risk_factors = ['risk', 'concern', 'challenge', 'threat', 'uncertainty', 'decline', 'loss']
        risk_score = sum(1 for factor in risk_factors if factor in text_lower) / len(risk_factors)
        
        return {
            'sentiment_scores': sentiment_scores,
            'primary_sentiment': primary_sentiment,
            'confidence': confidence,
            'market_impact': impact_level,
            'volatility_score': volatility_score,
            'risk_score': risk_score
        }
        
    except Exception as e:
        return None

def generate_trading_signals(analysis_result, entities, risk_tolerance, investment_horizon):
    """Generate actionable trading signals based on sentiment analysis"""
    
    if not analysis_result:
        return None
    
    sentiment = analysis_result['primary_sentiment']
    confidence = analysis_result['confidence']
    impact = analysis_result['market_impact']
    risk_score = analysis_result['risk_score']
    
    # Base signal determination
    if sentiment == 'bullish' and confidence > 0.7:
        base_signal = 'BUY'
    elif sentiment == 'bearish' and confidence > 0.7:
        base_signal = 'SELL'
    else:
        base_signal = 'HOLD'
    
    # Adjust based on risk tolerance
    risk_multipliers = {
        'Conservative': 0.7,
        'Moderate': 1.0,
        'Aggressive': 1.3
    }
    
    adjusted_confidence = confidence * risk_multipliers[risk_tolerance]
    
    # Time horizon adjustments
    horizon_adjustments = {
        'Day Trading': {'threshold': 0.8, 'hold_bias': 0.1},
        'Swing (1-7 days)': {'threshold': 0.7, 'hold_bias': 0.2},
        'Position (1-3 months)': {'threshold': 0.6, 'hold_bias': 0.3},
        'Long-term (6+ months)': {'threshold': 0.5, 'hold_bias': 0.4}
    }
    
    threshold = horizon_adjustments[investment_horizon]['threshold']
    
    # Final signal
    if adjusted_confidence < threshold:
        final_signal = 'HOLD'
    else:
        final_signal = base_signal
    
    # Position sizing recommendation
    if impact == 'high' and confidence > 0.8:
        position_multiplier = 1.2
    elif impact == 'low' or confidence < 0.6:
        position_multiplier = 0.7
    else:
        position_multiplier = 1.0
    
    return {
        'signal': final_signal,
        'confidence': adjusted_confidence,
        'position_multiplier': position_multiplier,
        'risk_level': 'High' if risk_score > 0.6 else 'Medium' if risk_score > 0.3 else 'Low',
        'rationale': f"{sentiment.title()} sentiment ({confidence:.1%}) with {impact} market impact"
    }

def create_sentiment_dashboard(analysis_result, entities, trading_signal):
    """Create comprehensive financial dashboard"""
    
    if not analysis_result:
        return None
    
    # Create subplots
    fig = make_subplots(
        rows=2, cols=2,
        subplot_titles=('Sentiment Distribution', 'Market Impact vs Confidence', 'Risk Assessment', 'Trading Signal'),
        specs=[[{"type": "bar"}, {"type": "scatter"}],
               [{"type": "indicator"}, {"type": "bar"}]]
    )
    
    # Sentiment distribution
    sentiments = list(analysis_result['sentiment_scores'].keys())
    scores = list(analysis_result['sentiment_scores'].values())
    colors = ['#f44336', '#ff9800', '#4caf50']
    
    fig.add_trace(
        go.Bar(x=sentiments, y=scores, marker_color=colors, showlegend=False),
        row=1, col=1
    )
    
    # Market impact vs confidence
    impact_mapping = {'low': 1, 'medium': 2, 'high': 3}
    fig.add_trace(
        go.Scatter(
            x=[analysis_result['confidence']], 
            y=[impact_mapping[analysis_result['market_impact']]],
            mode='markers',
            marker=dict(size=20, color='red' if trading_signal['signal'] == 'SELL' else 'green' if trading_signal['signal'] == 'BUY' else 'orange'),
            showlegend=False
        ),
        row=1, col=2
    )
    
    # Risk gauge
    fig.add_trace(
        go.Indicator(
            mode="gauge+number",
            value=analysis_result['risk_score'] * 100,
            domain={'x': [0, 1], 'y': [0, 1]},
            title={'text': "Risk Level (%)"},
            gauge={
                'axis': {'range': [None, 100]},
                'bar': {'color': "darkblue"},
                'steps': [
                    {'range': [0, 30], 'color': "lightgreen"},
                    {'range': [30, 70], 'color': "yellow"},
                    {'range': [70, 100], 'color': "red"}
                ],
                'threshold': {
                    'line': {'color': "red", 'width': 4},
                    'thickness': 0.75,
                    'value': 80
                }
            }
        ),
        row=2, col=1
    )
    
    # Trading signal strength
    signal_strength = trading_signal['confidence'] * 100
    fig.add_trace(
        go.Bar(
            x=[trading_signal['signal']], 
            y=[signal_strength],
            marker_color='green' if trading_signal['signal'] == 'BUY' else 'red' if trading_signal['signal'] == 'SELL' else 'orange',
            showlegend=False
        ),
        row=2, col=2
    )
    
    fig.update_layout(height=600, title_text="Financial Sentiment Analysis Dashboard")
    return fig

# Load models
tokenizer, model, ner_pipeline, error = load_financial_models()

if error:
    st.error(f"Failed to load models: {error}")
    st.stop()

if tokenizer and model:
    st.success("✅ Financial AI models loaded successfully!")
    
    if analysis_type == "Single News Analysis":
        st.header("📰 Single News Analysis")
        
        col1, col2 = st.columns([2, 1])
        
        with col1:
            news_text = st.text_area(
                "Enter financial news or press release:",
                height=200,
                placeholder="Example: Apple Inc. reported record quarterly earnings of $123.9 billion, beating analyst expectations by 15%. The company's iPhone sales surged 25% year-over-year, driven by strong demand for the new iPhone 15 series..."
            )
            
            col_a, col_b = st.columns(2)
            with col_a:
                analyze_btn = st.button("🔍 Analyze News", type="primary")
            with col_b:
                if st.button("📊 Get Sample News"):
                    sample_news = [
                        "Tesla reports record Q4 deliveries, exceeding analyst expectations by 12%. Stock surges in after-hours trading.",
                        "Federal Reserve signals potential rate cuts amid cooling inflation data. Markets rally on dovish commentary.",
                        "Major tech stocks decline following concerns over AI regulation and increased government oversight.",
                    ]
                    st.session_state.sample_news = np.random.choice(sample_news)
            
            if 'sample_news' in st.session_state:
                news_text = st.session_state.sample_news
        
        with col2:
            st.subheader("🎯 Quick Actions")
            if st.button("📈 Market Impact Simulator"):
                st.info("Feature available in Pro version")
            if st.button("📧 Setup Alert"):
                st.info("Alert configured successfully!")
            if st.button("💾 Save Analysis"):
                st.info("Analysis saved to portfolio")
        
        if analyze_btn and news_text.strip():
            with st.spinner("🤖 Analyzing financial sentiment..."):
                # Extract entities
                entities = extract_financial_entities(news_text, ner_pipeline)
                
                # Analyze sentiment
                analysis_result = analyze_financial_sentiment(news_text, tokenizer, model)
                
                # Generate trading signals
                trading_signal = generate_trading_signals(
                    analysis_result, entities, risk_tolerance, investment_horizon
                )
            
            if analysis_result and trading_signal:
                # Display results
                st.header("📊 Financial Analysis Results")
                
                # Key metrics row
                col1, col2, col3, col4 = st.columns(4)
                
                with col1:
                    sentiment_emoji = "🐂" if analysis_result['primary_sentiment'] == 'bullish' else "🐻" if analysis_result['primary_sentiment'] == 'bearish' else "➡️"
                    st.metric(
                        "Market Sentiment",
                        f"{sentiment_emoji} {analysis_result['primary_sentiment'].title()}",
                        f"{analysis_result['confidence']:.1%} confidence"
                    )
                
                with col2:
                    impact_emoji = "🔴" if analysis_result['market_impact'] == 'high' else "🟡" if analysis_result['market_impact'] == 'medium' else "🟢"
                    st.metric(
                        "Market Impact",
                        f"{impact_emoji} {analysis_result['market_impact'].title()}",
                        f"Risk: {trading_signal['risk_level']}"
                    )
                
                with col3:
                    st.metric(
                        "Volatility Score",
                        f"{analysis_result['volatility_score']:.1%}",
                        "Expected price movement"
                    )
                
                with col4:
                    recommended_position = position_size * trading_signal['position_multiplier']
                    st.metric(
                        "Position Size",
                        f"${recommended_position:,.0f}",
                        f"{(trading_signal['position_multiplier']-1)*100:+.0f}% vs base"
                    )
                
                # Trading signal
                signal_class = f"{trading_signal['signal'].lower()}-signal"
                st.markdown(f"""
                <div class="trading-signal {signal_class}">
                    🎯 TRADING SIGNAL: {trading_signal['signal']} 
                    <br><small>{trading_signal['rationale']}</small>
                </div>
                """, unsafe_allow_html=True)
                
                # Detailed analysis
                col1, col2 = st.columns(2)
                
                with col1:
                    st.subheader("📈 Sentiment Breakdown")
                    for sentiment, score in analysis_result['sentiment_scores'].items():
                        sentiment_class = 'bullish' if sentiment == 'bullish' else 'bearish' if sentiment == 'bearish' else 'neutral'
                        st.markdown(f"""
                        <div class="metric-card {sentiment_class}">
                            <h4>{'🐂' if sentiment == 'bullish' else '🐻' if sentiment == 'bearish' else '➡️'} {sentiment.title()}</h4>
                            <h2>{score:.3f}</h2>
                            <div style="width: 100%; background-color: #ddd; border-radius: 25px; height: 10px;">
                                <div style="width: {score*100}%; height: 10px; background-color: {'#4caf50' if sentiment == 'bullish' else '#f44336' if sentiment == 'bearish' else '#ff9800'}; border-radius: 25px;"></div>
                            </div>
                        </div>
                        """, unsafe_allow_html=True)
                
                with col2:
                    st.subheader("🏷️ Extracted Entities")
                    
                    if entities.get('companies'):
                        st.write("**Companies:** " + ", ".join(entities['companies']))
                    if entities.get('stocks'):
                        st.write("**Stock Symbols:** " + ", ".join(entities['stocks']))
                    if entities.get('sectors'):
                        st.write("**Sectors:** " + ", ".join(entities['sectors']))
                    if entities.get('metrics'):
                        st.write("**Financial Metrics:** " + ", ".join(entities['metrics']))
                    
                    # Risk indicators
                    st.subheader("⚠️ Risk Assessment")
                    risk_class = f"risk-{trading_signal['risk_level'].lower()}"
                    st.markdown(f'<span class="risk-indicator {risk_class}">{trading_signal["risk_level"]} Risk</span>', unsafe_allow_html=True)
                
                # Dashboard visualization
                st.subheader("📊 Interactive Dashboard")
                dashboard_fig = create_sentiment_dashboard(analysis_result, entities, trading_signal)
                if dashboard_fig:
                    st.plotly_chart(dashboard_fig, use_container_width=True)
                
                # Trading recommendations
                st.subheader("💡 Trading Recommendations")
                
                recommendations = []
                
                if trading_signal['signal'] == 'BUY':
                    recommendations.extend([
                        f"✅ Consider opening a long position with {trading_signal['confidence']:.1%} confidence",
                        f"🎯 Recommended position size: ${recommended_position:,.0f}",
                        f"⏰ Time horizon: {investment_horizon}",
                        "📊 Monitor for confirmation signals in next 24-48 hours"
                    ])
                elif trading_signal['signal'] == 'SELL':
                    recommendations.extend([
                        f"❌ Consider reducing exposure or opening short position",
                        f"🛡️ Implement stop-loss at current levels",
                        f"⚠️ High risk scenario - monitor closely",
                        "📉 Consider defensive positioning"
                    ])
                else:
                    recommendations.extend([
                        f"⏸️ Hold current positions - mixed signals detected",
                        f"👀 Wait for clearer market direction",
                        f"📊 Monitor for breakthrough above {sentiment_threshold:.1%} confidence",
                        "🔄 Re-evaluate in 24-48 hours"
                    ])
                
                for rec in recommendations:
                    st.write(rec)
                
                # Export options
                st.subheader("📥 Export & Alerts")
                col1, col2, col3 = st.columns(3)
                
                with col1:
                    if st.button("📊 Export Report"):
                        report_data = {
                            'timestamp': datetime.now().isoformat(),
                            'news_text': news_text[:200] + "...",
                            'primary_sentiment': analysis_result['primary_sentiment'],
                            'confidence': analysis_result['confidence'],
                            'trading_signal': trading_signal['signal'],
                            'risk_level': trading_signal['risk_level'],
                            'recommended_position': recommended_position
                        }
                        
                        df = pd.DataFrame([report_data])
                        csv = df.to_csv(index=False)
                        st.download_button(
                            "📥 Download Analysis Report",
                            csv,
                            f"financial_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
                            "text/csv"
                        )
                
                with col2:
                    if st.button("🔔 Setup Price Alert"):
                        st.success("Price alert configured for significant moves!")
                
                with col3:
                    if st.button("📧 Email Report"):
                        st.success("Report emailed to your registered address!")
    
    elif analysis_type == "Portfolio Impact Analysis":
        st.header("💼 Portfolio Impact Analysis")
        st.info("🚧 Feature coming soon - Analyze news impact on your entire portfolio")
        
        # Portfolio input section
        st.subheader("📊 Your Portfolio")
        portfolio_input = st.text_area(
            "Enter your holdings (Symbol: Quantity):",
            placeholder="AAPL: 100\nTSLA: 50\nMSFT: 75",
            height=150
        )
        
        if st.button("📈 Analyze Portfolio Impact"):
            st.success("Portfolio analysis feature will be available in the next update!")
    
    elif analysis_type == "Market Sector Analysis":
        st.header("🏭 Market Sector Analysis")
        st.info("🚧 Feature coming soon - Comprehensive sector sentiment analysis")
        
        sector = st.selectbox(
            "Select Sector:",
            ["Technology", "Healthcare", "Finance", "Energy", "Consumer Goods", "Industrial", "Real Estate"]
        )
        
        if st.button("🔍 Analyze Sector"):
            st.success("Sector analysis feature will be available in the next update!")
    
    else:  # Real-time News Feed
        st.header("📡 Real-time News Feed Analysis")
        st.info("🚧 Feature coming soon - Live news sentiment monitoring")
        
        if st.button("🔄 Start Live Monitoring"):
            st.success("Live monitoring feature will be available in the next update!")

# Footer
st.markdown("---")
st.markdown("""
<div style='text-align: center; color: #666; margin-top: 2rem;'>
    <p><strong>⚠️ Disclaimer:</strong> This analysis is for informational purposes only and should not be considered as financial advice.</p>
    <p>Always consult with a qualified financial advisor before making investment decisions.</p>
    <p>🤖 Powered by Advanced AI • Built for Professional Traders & Investors</p>
</div>
""", unsafe_allow_html=True)