app.py

import streamlit as st
import yfinance as yf
import alpaca_trade_api as alpaca
from newsapi import NewsApiClient
from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
from datetime import datetime, timedelta
import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt
import logging
import threading
import time
import json
import os
import plotly.graph_objs as go
from sklearn.preprocessing import minmax_scale
from plotly.subplots import make_subplots

# Configure logging with timestamps
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)
logger = logging.getLogger(__name__)

# Use session state keys instead of file paths
AUTO_TRADE_LOG_KEY = "auto_trade_log"  # Session state key for trade log
AUTO_TRADE_INTERVAL = 10800  # Interval in seconds (e.g., 10800 seconds = 3 hours)
st.set_page_config(layout="wide")

class AlpacaTrader:
    def __init__(self, API_KEY, API_SECRET, BASE_URL):
        self.alpaca = alpaca.REST(API_KEY, API_SECRET, BASE_URL)
        self.cash = 0
        self.holdings = {}
        self.trades = []

    def get_market_status(self):
        return self.alpaca.get_clock().is_open

    def buy(self, symbol, qty, reason=None):
        try:
            # Ensure at least $1000 in cash before buying
            account = self.alpaca.get_account()
            cash_balance = float(account.cash)
            if cash_balance < 1000:
                logger.warning(f"Low cash: (${cash_balance}) to buy {symbol}. Minimum $1000 required.")
                return None
            order = self.alpaca.submit_order(symbol=symbol, qty=qty, side='buy', type='market', time_in_force='day')
            if reason:
                logger.info(f"Bought {qty} shares of {symbol} [Reason: {reason}]")
            else:
                logger.info(f"Bought {qty} shares of {symbol}")
            
            # Record the trade
            if order:
                self.trades.append({
                    'symbol': symbol, 
                    'qty': qty, 
                    'action': 'Buy', 
                    'time': datetime.now(),
                    'reason': reason
                })
            
            return order
        except Exception as e:
            logger.error(f"Error buying {symbol}: {e}")
            return None

    def sell(self, symbol, qty, reason=None):
        # Check if position exists and has enough quantity before attempting to sell
        positions = {p.symbol: float(p.qty) for p in self.alpaca.list_positions()}
        if symbol not in positions:
            logger.warning(f"No position in {symbol}. Sell not attempted.")
            return None
        if positions[symbol] < qty:
            logger.warning(f"Not enough shares to sell: {qty} requested, {positions[symbol]} available for {symbol}. Sell not attempted.")
            return None
        try:
            order = self.alpaca.submit_order(symbol=symbol, qty=qty, side='sell', type='market', time_in_force='day')
            if reason:
                logger.info(f"Sold {qty} shares of {symbol} [Reason: {reason}]")
            else:
                logger.info(f"Sold {qty} shares of {symbol}")
            
            # Record the trade
            if order:
                self.trades.append({
                    'symbol': symbol, 
                    'qty': qty, 
                    'action': 'Sell', 
                    'time': datetime.now(),
                    'reason': reason
                })
            
            return order
        except Exception as e:
            logger.error(f"Error selling {symbol}: {e}")
            return None

    def getHoldings(self):
        positions = self.alpaca.list_positions()
        for position in positions:
            self.holdings[position.symbol] = float(position.market_value)
        
        # Return holdings as a dictionary for internal use
        return self.holdings

    def getCash(self):
        return self.alpaca.get_account().cash

    def update_portfolio(self, symbol, price, qty, action):
        if action == 'buy':
            self.cash -= price * qty
            if symbol in self.holdings:
                self.holdings[symbol] += price * qty
            else:
                self.holdings[symbol] = price * qty
        elif action == 'sell':
            self.cash += price * qty
            self.holdings[symbol] -= price * qty
            if self.holdings[symbol] <= 0:
                del self.holdings[symbol]
        self.trades.append({'symbol': symbol, 'price': price, 'qty': qty, 'action': action, 'time': datetime.now()})

class NewsSentiment:
    def __init__(self, API_KEY):
        self.newsapi = NewsApiClient(api_key=API_KEY)
        self.sia = SentimentIntensityAnalyzer()
        self.alpha_vantage_api_key = st.secrets.get("ALPHA_VANTAGE_API_KEY")

    def get_sentiment_and_headlines(self, symbol):
        """
        Try NewsAPI first, fallback to Alpha Vantage if needed.
        Returns (sentiment, headlines, source).
        """
        # Try NewsAPI
        try:
            articles = self.newsapi.get_everything(q=symbol, language='en', sort_by='publishedAt', page=1)
            headlines = [a['title'] for a in articles.get('articles', [])[:5]]
            if headlines:
                sentiment = self._calculate_sentiment(headlines)
                logger.info(f"NewsAPI sentiment for {symbol}: {sentiment} | Headlines: {headlines}")
                return sentiment, headlines, "NewsAPI"
            else:
                logger.warning(f"NewsAPI returned no headlines for {symbol}.")
        except Exception as e:
            logger.error(f"NewsAPI error for {symbol}: {e}")
            logger.info(f"Falling back to Alpha Vantage for {symbol} sentiment and headlines.")

        # Fallback to Alpha Vantage
        try:
            if not self.alpha_vantage_api_key:
                logger.error("Alpha Vantage API key not found in Streamlit secrets.")
                return None, [], "AlphaVantage"
            import requests
            url = (
                f"https://www.alphavantage.co/query?function=NEWS_SENTIMENT&tickers={symbol}"
                f"&apikey={self.alpha_vantage_api_key}"
            )
            resp = requests.get(url)
            data = resp.json()
            headlines = [item.get("title") for item in data.get("feed", [])[:5] if item.get("title")]
            if headlines:
                sentiment = self._calculate_sentiment(headlines)
                logger.info(f"Alpha Vantage sentiment for {symbol}: {sentiment} | Headlines: {headlines}")
                return sentiment, headlines, "AlphaVantage"
            else:
                logger.warning(f"Alpha Vantage returned no headlines for {symbol}.")
        except Exception as e:
            logger.error(f"Alpha Vantage error for {symbol}: {e}")

        logger.info(
            f"No sentiment/headlines available for {symbol} from either NewsAPI or Alpha Vantage."
        )
        return None, [], None

    def _calculate_sentiment(self, headlines):
        if not headlines:
            return None
        compound_score = sum(self.sia.polarity_scores(title)['compound'] for title in headlines)
        avg_score = compound_score / len(headlines)
        if avg_score > 0.1:
            return 'Positive'
        elif avg_score < -0.1:
            return 'Negative'
        else:
            return 'Neutral'

    def get_sentiment_bulk(self, symbols):
        """
        Bulk sentiment for a list of symbols using NewsAPI only (for auto-trade).
        Returns dict: symbol -> (sentiment, source).
        """
        sentiment = {}
        for symbol in symbols:
            try:
                articles = self.newsapi.get_everything(q=symbol, language='en', sort_by='publishedAt', page=1)
                headlines = [a['title'] for a in articles.get('articles', [])[:5]]
                if headlines:
                    s = self._calculate_sentiment(headlines)
                    logger.info(f"NewsAPI sentiment for {symbol}: {s} | Headlines: {headlines}")
                    sentiment[symbol] = (s, "NewsAPI")
                else:
                    # fallback to Alpha Vantage
                    s, _, src = self.get_sentiment_and_headlines(symbol)
                    sentiment[symbol] = (s, src)
            except Exception as e:
                logger.error(f"Error getting news for {symbol}: {e}")
                # fallback to Alpha Vantage
                s, _, src = self.get_sentiment_and_headlines(symbol)
                sentiment[symbol] = (s, src)
        return sentiment




class StockAnalyzer:
    def __init__(self, alpaca):
        self.alpaca = alpaca
        self.symbols = self.get_top_volume_stocks()
        # Build a symbol->name mapping for use in plots/tables
        self.symbol_to_name = self.get_symbol_to_name()

    def get_symbol_to_name(self):
        # Get mapping from symbol to company name using Alpaca asset info
        assets = self.alpaca.alpaca.list_assets(status='active')
        return {asset.symbol: asset.name for asset in assets}

    def get_bars(self, alp_api, symbols, timeframe='1D'):
        bars_data = {}
        try:
            bars = alp_api.get_bars(list(symbols), timeframe).df
            if 'symbol' not in bars.columns:
                logger.warning("The 'symbol' column is missing in the bars DataFrame.")
                return {symbol: {'bar_data': None} for symbol in symbols}

            for symbol in symbols:
                symbol_bars = bars[bars['symbol'] == symbol]
                if not symbol_bars.empty:
                    bar_info = symbol_bars.iloc[-1]
                    # Handle index type for timestamp
                    if isinstance(bar_info.name, tuple):
                        timestamp = bar_info.name[1].isoformat()
                    else:
                        timestamp = bar_info.name.isoformat()
                    bars_data[symbol] = {
                        'bar_data': {
                            'volume': bar_info['volume'],
                            'open': bar_info['open'],
                            'high': bar_info['high'],
                            'low': bar_info['low'],
                            'close': bar_info['close'],
                            'timestamp': timestamp
                        }
                    }
                else:
                    logger.debug(f"No bar data for symbol: {symbol}")
                    bars_data[symbol] = {'bar_data': None}
        except Exception as e:
            logger.warning(f"Error fetching bars in batch: {e}")
            for symbol in symbols:
                bars_data[symbol] = {'bar_data': None}
        return bars_data

    def assetswithconditions(self,stock_assets):
        cond = {
            'class': ['us_equity'],
            'exchange': ['NASDAQ', 'NYSE'],
            'status': ['active'],
            'tradable': [True],
            'marginable': [True],
            'shortable': [True],
            'easy_to_borrow': [True],
            'fractionable': [True]
        }
        assets_with_conditions = []
        asset_symbol_dict = {}
        
        for asset in stock_assets:
            # Skip symbols with '.' or '/' (preferred shares, warrants, etc.)
            if '.' in asset.symbol or '/' in asset.symbol:
                continue

            if (asset.__getattr__('class') in cond['class'] and 
                asset.exchange in cond['exchange'] and
                asset.status in cond['status'] and
                asset.tradable in cond['tradable'] and
                asset.marginable in cond['marginable'] and
                asset.shortable in cond['shortable'] and 
                asset.easy_to_borrow in cond['easy_to_borrow'] and
                asset.fractionable in cond['fractionable']
                ):
                assets_with_conditions.append(asset)
                
                asset_no_comma = asset.name.replace(',', '')
                asset_first_word = asset_no_comma.split()[0]

                asset_symbol_dict[asset.symbol] = asset._raw
                asset_symbol_dict[asset.symbol]['firstWord'] = asset_first_word
                
                sorted_dict = dict(sorted(asset_symbol_dict.items()))
        # print(f'Length of Alpaca assets with conditions = {len(assets_with_conditions)}')
        # print(f'assets_with_conditions = {assets_with_conditions}')
        return assets_with_conditions, sorted_dict


    def get_top_volume_stocks(self,num_stocks=10):
        try:
            # Get all tradable assets
            assets = self.alpaca.alpaca.list_assets(status='active')
            # tradable_assets = {asset.symbol: {} for asset in assets if asset.tradable}
            # print(f'tradable_assets = {tradable_assets}')

            assets_with_conditions, sorted_dict = self.assetswithconditions(assets)
            # print(f'sorted_dict = {sorted_dict}')
            # Fetch bar data for all tradable assets
            # print(f'sorted_dict.keys()={sorted_dict.keys()}')
            tradable_assets = self.get_bars(self.alpaca.alpaca, sorted_dict.keys(), timeframe='1D')

            # Extract volume and calculate the top 10 stocks by volume
            volume_data = {
                symbol: info['bar_data']['volume']
                for symbol, info in tradable_assets.items()
                if info['bar_data'] is not None
            }
            top_volume_stocks = sorted(volume_data, key=volume_data.get, reverse=True)[:num_stocks]
            logger.info(f'top_volume_stocks = {top_volume_stocks}')

            return top_volume_stocks
        except Exception as e:
            logger.error(f"Error fetching top volume stocks: {e}")
            return []

    def get_historical_data(self, symbols):
        data = {}
        for symbol in symbols:
            try:
                # Pull historical data from 2000-01-01 to today, daily interval
                ticker = yf.Ticker(symbol)
                hist = ticker.history(start='2023-01-01', end=datetime.now().strftime('%Y-%m-%d'), interval='1d')
                data[symbol] = hist
            except Exception as e:
                logger.error(f"Error getting data for {symbol}: {e}")
        return data

class TradingApp:
    def __init__(self):
        self.alpaca = AlpacaTrader(st.secrets['ALPACA_API_KEY'], st.secrets['ALPACA_SECRET_KEY'], 'https://paper-api.alpaca.markets')
        self.sentiment = NewsSentiment(st.secrets['NEWS_API_KEY'])
        self.analyzer = StockAnalyzer(self.alpaca)
        self.data = self.analyzer.get_historical_data(self.analyzer.symbols)
        self.auto_trade_log = []

    def display_charts(self):
        # Dynamically adjust columns based on number of stocks and available width
        symbols = list(self.data.keys())
        if not symbols:
            st.warning("No stock data available to display charts.")
            return  # Exit the function if no symbols are available

        symbol_to_name = self.analyzer.symbol_to_name
        n = len(symbols)
        # Calculate columns based on n for best fit
        cols = 3
        rows = (n + cols - 1) // cols
        subplot_titles = [
            f"{symbol} - {symbol_to_name.get(symbol, '')}" for symbol in symbols
        ]
        fig = make_subplots(rows=rows, cols=cols, subplot_titles=subplot_titles)
        for idx, symbol in enumerate(symbols):
            df = self.data[symbol]
            if not df.empty:
                row = idx // cols + 1
                col = idx % cols + 1
                fig.add_trace(
                    go.Scatter(
                        x=df.index,
                        y=df['Close'],
                        mode='lines',
                        name=symbol,
                        hovertemplate=f"%{{x}}<br>{symbol}: %{{y:.2f}}<extra></extra>"
                    ),
                    row=row,
                    col=col
                )
        fig.update_layout(
            title="Top Volume Stocks - Price Charts (Since 2023)",
            height=max(400 * rows, 600),
            showlegend=False,
            dragmode=False,
        )
        # Enable scroll-zoom for each subplot (individual zoom)
        fig.update_layout(
            xaxis=dict(fixedrange=False),
            yaxis=dict(fixedrange=False),
        )
        for i in range(1, rows * cols + 1):
            fig.layout[f'xaxis{i}'].update(fixedrange=False)
            fig.layout[f'yaxis{i}'].update(fixedrange=False)
        st.plotly_chart(fig, use_container_width=True, config={"scrollZoom": True})

    def manual_trade(self):
        # Move all user inputs to the sidebar
        with st.sidebar:
            st.header("Manual Trade")
            symbol = st.text_input('Enter stock symbol')

            # --- Unified Sentiment Check Feature ---
            if "sentiment_result" not in st.session_state:
                st.session_state["sentiment_result"] = None
            if "article_headlines" not in st.session_state:
                st.session_state["article_headlines"] = []
            if "sentiment_source" not in st.session_state:
                st.session_state["sentiment_source"] = None

            if st.button("Check Sentiment"):
                if symbol:
                    sentiment_result, article_headlines, sentiment_source = self.sentiment.get_sentiment_and_headlines(symbol)
                    st.session_state["sentiment_result"] = sentiment_result
                    st.session_state["article_headlines"] = article_headlines
                    st.session_state["sentiment_symbol"] = symbol
                    st.session_state["sentiment_source"] = sentiment_source
                else:
                    st.session_state["sentiment_result"] = None
                    st.session_state["article_headlines"] = []
                    st.session_state["sentiment_symbol"] = ""
                    st.session_state["sentiment_source"] = None

            sentiment_result = st.session_state.get("sentiment_result")
            article_headlines = st.session_state.get("article_headlines", [])
            sentiment_symbol = st.session_state.get("sentiment_symbol", "")
            sentiment_source = st.session_state.get("sentiment_source", "")

            if symbol and sentiment_symbol == symbol and sentiment_result is not None:
                st.markdown(f"**Sentiment for {symbol.upper()} ({sentiment_source}):** {sentiment_result if sentiment_result in ['Positive', 'Negative', 'Neutral'] else 'No sentiment available'}")
            elif symbol and sentiment_symbol == symbol and sentiment_result is None:
                st.markdown("**Sentiment:** No sentiment available")

            if symbol and sentiment_symbol == symbol and article_headlines:
                st.markdown("**Recent Headlines:**")
                for headline in article_headlines:
                    st.write(f"- {headline}")
            elif symbol and sentiment_symbol == symbol and sentiment_result is not None and not article_headlines:
                st.markdown("_No headlines available._")

            # Fetch the current stock price dynamically using Alpaca's API
            def get_stock_price(symbol):
                try:
                    if not symbol:
                        return None
                    last_trade = self.alpaca.alpaca.get_latest_trade(symbol)
                    return last_trade.price
                except Exception as e:
                    logger.error(f"Error fetching stock price for {symbol}: {e}")
                    return None

            # Update stock price when a new symbol is entered
            if symbol:
                if "stock_price" not in st.session_state or st.session_state.get("last_symbol") != symbol:
                    st.session_state["stock_price"] = get_stock_price(symbol)
                    st.session_state["last_symbol"] = symbol

            stock_price = st.session_state.get("stock_price")
            # Explicitly display the stock price below the input field
            if stock_price is not None:
                st.write(f"Current stock price for {symbol.upper()}: ${stock_price:,.2f}")
            else:
                st.write("Enter a valid stock symbol to see the price.")

            # Allow user to enter either quantity or amount
            trade_option = st.radio("Trade Option", ["Enter Quantity", "Enter Amount"])
            qty = st.number_input('Enter quantity', min_value=0.0, step=0.01, value=0.0) if trade_option == "Enter Quantity" else None
            amount = st.number_input('Enter amount ($)', min_value=0.0, step=0.01, value=0.0) if trade_option == "Enter Amount" else None

            # Dynamically calculate the other field
            if stock_price:
                if trade_option == "Enter Quantity" and qty:
                    amount = qty * stock_price
                    st.write(f"Calculated Amount: ${amount:,.2f}")
                elif trade_option == "Enter Amount" and amount:
                    qty = float(amount / stock_price)
                    st.write(f"Calculated Quantity: {qty:,.2f}")

            action = st.selectbox('Action', ['Buy', 'Sell'])
            if st.button('Execute'):
                if stock_price and qty:
                    is_market_open = self.alpaca.get_market_status()
                    if action == 'Buy':
                        order = self.alpaca.buy(symbol, qty, reason="Manual Trade")
                    else:
                        order = self.alpaca.sell(symbol, qty, reason="Manual Trade")
                    
                    if order:
                        if not is_market_open:
                            _, _, next_open, _ = get_market_times(self.alpaca.alpaca)
                            next_open_time = next_open.strftime('%Y-%m-%d %H:%M:%S') if next_open else "unknown"
                            st.warning(f"Market is currently closed. The {action.lower()} order for {qty} shares of {symbol} has been submitted and will execute when the market opens at {next_open_time}.")
                        else:
                            st.success(f"Order executed: {action} {qty} shares of {symbol}")
                    else:
                        st.error("Order failed")
                else:
                    st.error("Please enter a valid stock symbol and trade details.")

            # Display portfolio information in the sidebar (restored)
            st.header("Alpaca Cash Portfolio")

            def refresh_portfolio():
                account = self.alpaca.alpaca.get_account()
                portfolio_data = {
                    "Metric": ["Cash Balance", "Buying Power", "Equity", "Portfolio Value"],
                    "Value": [
                        f"${int(float(account.cash)):,.0f}",
                        f"${int(float(account.buying_power)):,.0f}",
                        f"${int(float(account.equity)):,.0f}",
                        f"${int(float(account.portfolio_value)):,.0f}"
                    ]
                }
                df = pd.DataFrame(portfolio_data)
                st.table(df.to_dict(orient="records"))  # Convert DataFrame to a list of dictionaries

            refresh_portfolio()
            st.button("Refresh Portfolio", on_click=refresh_portfolio)

    def auto_trade_based_on_sentiment(self, sentiment):
        actions = self._execute_sentiment_trades(sentiment)
        self.auto_trade_log = actions
        return actions

    def _execute_sentiment_trades(self, sentiment):
        actions = []
        symbol_to_name = self.analyzer.symbol_to_name
        for symbol, sentiment_info in sentiment.items():
            # sentiment_info is now (sentiment, source)
            if isinstance(sentiment_info, tuple):
                sentiment_value, sentiment_source = sentiment_info
            else:
                sentiment_value, sentiment_source = sentiment_info, None
            # If sentiment is missing or invalid, try to get it using fallback
            if sentiment_value is None or sentiment_value not in ['Positive', 'Negative', 'Neutral']:
                sentiment_value, _, sentiment_source = self.sentiment.get_sentiment_and_headlines(symbol)
            action = None
            is_market_open = self.alpaca.get_market_status()
            logger.info(f"Auto-trade: {symbol} | Sentiment: {sentiment_value} | Source: {sentiment_source}")
            if sentiment_value == 'Positive':
                order = self.alpaca.buy(symbol, 1, reason=f"Sentiment: Positive ({sentiment_source})")
                action = 'Buy'
            elif sentiment_value == 'Negative':
                order = self.alpaca.sell(symbol, 1, reason=f"Sentiment: Negative ({sentiment_source})")
                action = 'Sell'
            else:
                order = None
                action = 'Hold'
                logger.info(f"Held {symbol}")

            if order:
                if not is_market_open:
                    _, _, next_open, _ = get_market_times(self.alpaca.alpaca)
                    next_open_time = next_open.strftime('%Y-%m-%d %H:%M:%S') if next_open else "unknown"
                    logger.warning(f"Market is currently closed. The {action.lower()} order for 1 share of {symbol} has been submitted and will execute when the market opens at {next_open_time}.")
                else:
                    logger.info(f"Order executed: {action} 1 share of {symbol}")

            actions.append({
                'symbol': symbol,
                'company_name': symbol_to_name.get(symbol, ''),
                'sentiment': sentiment_value,
                'sentiment_source': sentiment_source,
                'action': action
            })
        return actions

def background_auto_trade(app):
    """This function runs in a background thread and updates session state with automatic trades."""
    while True:
        start_time = time.time()
        # Use NewsAPI and Alpha Vantage for bulk sentiment (with fallback)
        sentiment = app.sentiment.get_sentiment_bulk(app.analyzer.symbols)
        actions = app._execute_sentiment_trades(sentiment)
        log_entry = {
            "timestamp": datetime.now().isoformat(),
            "actions": actions,
            "sentiment": sentiment
        }
        if AUTO_TRADE_LOG_KEY not in st.session_state:
            st.session_state[AUTO_TRADE_LOG_KEY] = []
        st.session_state[AUTO_TRADE_LOG_KEY].append(log_entry)
        if len(st.session_state[AUTO_TRADE_LOG_KEY]) > 50:
            st.session_state[AUTO_TRADE_LOG_KEY] = st.session_state[AUTO_TRADE_LOG_KEY][-50:]
        logger.info(f"Auto-trade completed. Actions: {actions}")
        elapsed_time = time.time() - start_time
        sleep_time = max(0, AUTO_TRADE_INTERVAL - elapsed_time)
        logger.info(f"Sleeping for {sleep_time:.2f} seconds before the next auto-trade.")
        time.sleep(sleep_time)

def get_auto_trade_log():
    """Get the auto trade log from session state."""
    if AUTO_TRADE_LOG_KEY not in st.session_state:
        st.session_state[AUTO_TRADE_LOG_KEY] = []
    return st.session_state[AUTO_TRADE_LOG_KEY]

def get_market_times(alpaca_api):
    try:
        clock = alpaca_api.get_clock()
        is_open = clock.is_open
        now = pd.Timestamp(clock.timestamp).tz_convert('America/New_York')
        next_close = pd.Timestamp(clock.next_close).tz_convert('America/New_York')
        next_open = pd.Timestamp(clock.next_open).tz_convert('America/New_York')
        return is_open, now, next_open, next_close
    except Exception as e:
        logger.error(f"Error fetching market times: {e}")
        return None, None, None, None

def main():
    st.title("Ben's Stock Trading Application")
    st.markdown("This is a fun stock trading application that uses a combination of key frameworks like Alpaca API, yfinance, and News API for stock information and trading. Come and trade my money! Well, it's a paper account, so it's not real money. But still, have fun!")

    if not st.secrets['ALPACA_API_KEY'] or not st.secrets['NEWS_API_KEY']:
        st.error("Please configure your ALPACA_API_KEY and NEWS_API_KEY")
        return

    # Prevent Streamlit from rerunning the script on every widget interaction
    # Use session state to persist objects and only update when necessary
    if "app_instance" not in st.session_state:
        st.session_state["app_instance"] = TradingApp()
    app = st.session_state["app_instance"]

    # Create two columns for market status and portfolio holdings
    col1, col2 = st.columns([1, 1])

    # Column 1: Portfolio holdings bar chart
    with col1:
        st.subheader("Portfolio Holdings")
        holdings_container = st.empty()  # Create a container for dynamic updates
        def update_holdings():
            holdings = app.alpaca.getHoldings()
            if holdings:
                df = pd.DataFrame(list(holdings.items()), columns=['Ticker', 'Market Value'])
                fig = go.Figure(
                    data=[
                        go.Bar(
                            x=df['Ticker'],
                            y=df['Market Value'],
                            marker=dict(color=df['Market Value'], colorscale='Viridis'),
                        )
                    ]
                )
                fig.update_layout(
                    xaxis_title="Ticker",
                    yaxis_title="$ USD",
                    height=400,
                )
                # Use a unique key by appending the current timestamp
                holdings_container.plotly_chart(fig, use_container_width=True, key=f"portfolio_holdings_chart_{time.time()}")
            else:
                holdings_container.info("No holdings to display.")

        # Periodically refresh the holdings plot
        update_holdings()
        st.button("Refresh Holdings", on_click=update_holdings)

        # Add an expandable section for detailed holdings
        st.subheader("Detailed Holdings")
        with st.expander("View Detailed Holdings"):
            holdings = app.alpaca.getHoldings()  # Use self.alpaca instead of app.alpaca
            if holdings:
                # Get positions to access both market value and quantity
                positions = app.alpaca.alpaca.list_positions()
                positions_data = []
                for position in positions:
                    positions_data.append({
                        "Ticker": position.symbol,
                        "Shares": float(position.qty),
                        "Amount (USD)": round(float(position.market_value))
                    })
                detailed_holdings = pd.DataFrame(positions_data)
                st.table(detailed_holdings)
            else:
                st.info("No holdings to display.")

    # Column 2: Market status
    with col2:
        is_open, now, next_open, next_close = get_market_times(app.alpaca.alpaca)
        market_status = "🟢 Market is OPEN" if is_open else "🔴 Market is CLOSED"
        st.markdown(f"### {market_status}")
        if now is not None:
            st.markdown(f"**Current time (ET):** {now.strftime('%Y-%m-%d %H:%M:%S')}")
        if is_open and next_close is not None:
            st.markdown(f"**Market closes at:** {next_close.strftime('%Y-%m-%d %H:%M:%S')} ET")
            seconds_left = int((next_close - now).total_seconds())
            st.markdown(f"**Time until close:** {pd.to_timedelta(seconds_left, unit='s')}")
        elif not is_open and next_open is not None:
            st.markdown(f"**Market opens at:** {next_open.strftime('%Y-%m-%d %H:%M:%S')} ET")
            seconds_left = int((next_open - now).total_seconds())
            st.markdown(f"**Time until open:** {pd.to_timedelta(seconds_left, unit='s')}")


    # Initialize auto trade log in session state if needed
    if AUTO_TRADE_LOG_KEY not in st.session_state:
        st.session_state[AUTO_TRADE_LOG_KEY] = []

    # Only start the background thread once
    if "auto_trade_thread_started" not in st.session_state:
        thread = threading.Thread(target=background_auto_trade, args=(app,), daemon=True)
        thread.start()
        st.session_state["auto_trade_thread_started"] = True

    # Main area: plots and data
    app.manual_trade()
    app.display_charts()

    # Read and display latest auto-trade actions
    st.write("Automatic Trading Actions Based on Sentiment (background):")
    auto_trade_log = get_auto_trade_log()
    if auto_trade_log:
        # Show the most recent entry
        last_entry = auto_trade_log[-1]
        st.write(f"Last checked: {last_entry['timestamp']}")
        df = pd.DataFrame(last_entry["actions"])
        if "company_name" in df.columns:
            # Show sentiment source if available
            display_cols = ["symbol", "company_name", "sentiment", "sentiment_source", "action"] if "sentiment_source" in df.columns else ["symbol", "company_name", "sentiment", "action"]
            df = df[display_cols]
        st.dataframe(df)
        st.write("Sentiment Analysis (latest):")
        st.write(last_entry["sentiment"])

        # Plot buy/sell actions over time
        st.write("Auto-Trading History (Buy/Sell Actions Over Time):")
        history = []
        for entry in auto_trade_log:
            ts = entry["timestamp"]
            for act in entry["actions"]:
                if act["action"] in ("Buy", "Sell"):
                    history.append({
                        "timestamp": ts,
                        "symbol": act["symbol"],
                        "action": act["action"]
                    })
        if history:
            hist_df = pd.DataFrame(history)
            if not hist_df.empty:
                hist_df["timestamp"] = pd.to_datetime(hist_df["timestamp"])
                hist_df["action_value"] = hist_df["action"].replace({"Buy": 1, "Sell": -1}).astype(float)
                pivot = hist_df.pivot_table(index="timestamp", columns="symbol", values="action_value", aggfunc="sum")
                st.line_chart(pivot.fillna(0))
    else:
        st.info("Waiting for first background auto-trade run...")


if __name__ == "__main__":
    main()