visualization_fallback.py

"""
Fallback visualization module using matplotlib when Plotly fails
"""

import matplotlib.pyplot as plt
import matplotlib.patches as patches
import seaborn as sns
import pandas as pd
import numpy as np
from typing import Dict, List, Tuple, Optional
import io
import base64


class MatplotlibVisualizer:
    """Fallback visualizer using matplotlib when Plotly is not available"""
    
    def __init__(self, theme: str = "light"):
        """
        Initialize visualizer
        
        Args:
            theme: Theme to use ('light' or 'dark')
        """
        self.theme = theme
        self.setup_style()
        
    def setup_style(self):
        """Setup matplotlib style"""
        if self.theme == "dark":
            plt.style.use('dark_background')
            self.colors = ['#00d4ff', '#ff6b6b', '#4ecdc4', '#45b7d1', '#96ceb4', '#feca57']
        else:
            plt.style.use('default')
            self.colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b']
        
        # Set default figure size
        plt.rcParams['figure.figsize'] = (10, 6)
        plt.rcParams['font.size'] = 10
    
    def plot_to_base64(self, fig) -> str:
        """Convert matplotlib figure to base64 string for Streamlit"""
        buffer = io.BytesIO()
        fig.savefig(buffer, format='png', dpi=300, bbox_inches='tight')
        buffer.seek(0)
        image_base64 = base64.b64encode(buffer.read()).decode()
        buffer.close()
        return image_base64
    
    def plot_efficient_frontier(self, efficient_frontier_data: pd.DataFrame, 
                              optimal_portfolio: Dict = None) -> str:
        """
        Create efficient frontier plot
        
        Args:
            efficient_frontier_data: DataFrame with portfolio data
            optimal_portfolio: Dictionary with optimal portfolio data
            
        Returns:
            Base64 encoded image string
        """
        fig, ax = plt.subplots(figsize=(10, 6))
        
        # Plot random portfolios
        scatter = ax.scatter(
            efficient_frontier_data['volatility'],
            efficient_frontier_data['return'],
            c=efficient_frontier_data['sharpe_ratio'],
            cmap='viridis',
            alpha=0.6,
            s=30
        )
        
        # Add colorbar
        cbar = plt.colorbar(scatter, ax=ax)
        cbar.set_label('Sharpe Ratio')
        
        # Plot optimal portfolio if provided
        if optimal_portfolio and 'metrics' in optimal_portfolio:
            metrics = optimal_portfolio['metrics']
            ax.scatter(
                metrics['volatility'],
                metrics['expected_return'],
                c='red',
                s=100,
                marker='*',
                label='Optimal Portfolio'
            )
        
        ax.set_xlabel('Volatility (Risk)')
        ax.set_ylabel('Expected Return')
        ax.set_title('Efficient Frontier')
        ax.legend()
        ax.grid(True, alpha=0.3)
        
        return self.plot_to_base64(fig)
    
    def plot_portfolio_weights(self, weights: Dict[str, float]) -> str:
        """
        Create pie chart for portfolio weights
        
        Args:
            weights: Dictionary with stock symbols and weights
            
        Returns:
            Base64 encoded image string
        """
        fig, ax = plt.subplots(figsize=(8, 8))
        
        symbols = list(weights.keys())
        weight_values = list(weights.values())
        
        wedges, texts, autotexts = ax.pie(
            weight_values,
            labels=symbols,
            autopct='%1.1f%%',
            colors=self.colors[:len(symbols)],
            startangle=90
        )
        
        ax.set_title('Portfolio Allocation')
        
        # Improve text readability
        for autotext in autotexts:
            autotext.set_color('white')
            autotext.set_fontweight('bold')
        
        return self.plot_to_base64(fig)
    
    def plot_capm_analysis(self, capm_results: pd.DataFrame, sml_data: pd.DataFrame) -> str:
        """
        Create CAPM Security Market Line plot
        
        Args:
            capm_results: DataFrame with CAPM analysis results
            sml_data: DataFrame with SML data points
            
        Returns:
            Base64 encoded image string
        """
        fig, ax = plt.subplots(figsize=(10, 6))
        
        # Plot Security Market Line
        ax.plot(
            sml_data['beta'],
            sml_data['expected_return'],
            'b--',
            linewidth=2,
            label='Security Market Line'
        )
        
        # Plot individual stocks
        for symbol in capm_results.index:
            ax.scatter(
                capm_results.loc[symbol, 'beta'],
                capm_results.loc[symbol, 'actual_return'],
                s=100,
                label=symbol,
                alpha=0.7
            )
            
            # Add stock symbol as annotation
            ax.annotate(
                symbol,
                (capm_results.loc[symbol, 'beta'], capm_results.loc[symbol, 'actual_return']),
                xytext=(5, 5),
                textcoords='offset points',
                fontsize=8
            )
        
        ax.set_xlabel('Beta (Systematic Risk)')
        ax.set_ylabel('Expected Return')
        ax.set_title('CAPM Analysis - Security Market Line')
        ax.legend()
        ax.grid(True, alpha=0.3)
        
        return self.plot_to_base64(fig)
    
    def plot_stock_forecasts(self, symbol: str, historical_prices: pd.Series, 
                           forecast_data: pd.DataFrame) -> str:
        """
        Create stock price forecast plot
        
        Args:
            symbol: Stock symbol
            historical_prices: Historical price data
            forecast_data: Forecast data with confidence intervals
            
        Returns:
            Base64 encoded image string
        """
        fig, ax = plt.subplots(figsize=(12, 6))
        
        # Plot historical prices
        ax.plot(
            historical_prices.index,
            historical_prices.values,
            'b-',
            linewidth=2,
            label='Historical Prices'
        )
        
        # Plot forecast
        ax.plot(
            forecast_data['date'],
            forecast_data['forecast'],
            'r--',
            linewidth=2,
            label='Forecast'
        )
        
        # Plot confidence intervals if available
        if 'lower_bound' in forecast_data.columns and 'upper_bound' in forecast_data.columns:
            ax.fill_between(
                forecast_data['date'],
                forecast_data['lower_bound'],
                forecast_data['upper_bound'],
                alpha=0.3,
                color='red',
                label='Confidence Interval'
            )
        
        ax.set_xlabel('Date')
        ax.set_ylabel('Price')
        ax.set_title(f'{symbol} Price Forecast')
        ax.legend()
        ax.grid(True, alpha=0.3)
        
        # Rotate x-axis labels for better readability
        plt.xticks(rotation=45)
        plt.tight_layout()
        
        return self.plot_to_base64(fig)
    
    def plot_correlation_heatmap(self, correlation_matrix: pd.DataFrame) -> str:
        """
        Create correlation heatmap
        
        Args:
            correlation_matrix: Correlation matrix DataFrame
            
        Returns:
            Base64 encoded image string
        """
        fig, ax = plt.subplots(figsize=(10, 8))
        
        # Create heatmap
        sns.heatmap(
            correlation_matrix,
            annot=True,
            cmap='RdBu_r',
            center=0,
            square=True,
            fmt='.2f',
            ax=ax
        )
        
        ax.set_title('Stock Correlation Matrix')
        
        return self.plot_to_base64(fig)
    
    def plot_risk_return_scatter(self, individual_metrics: pd.DataFrame) -> str:
        """
        Create risk-return scatter plot for individual stocks
        
        Args:
            individual_metrics: DataFrame with individual stock metrics
            
        Returns:
            Base64 encoded image string
        """
        fig, ax = plt.subplots(figsize=(10, 6))
        
        scatter = ax.scatter(
            individual_metrics['Volatility'],
            individual_metrics['Expected Return'],
            c=individual_metrics['Sharpe Ratio'],
            cmap='viridis',
            s=100,
            alpha=0.7
        )
        
        # Add stock labels
        for symbol in individual_metrics.index:
            ax.annotate(
                symbol,
                (individual_metrics.loc[symbol, 'Volatility'], 
                 individual_metrics.loc[symbol, 'Expected Return']),
                xytext=(5, 5),
                textcoords='offset points',
                fontsize=8
            )
        
        # Add colorbar
        cbar = plt.colorbar(scatter, ax=ax)
        cbar.set_label('Sharpe Ratio')
        
        ax.set_xlabel('Volatility (Risk)')
        ax.set_ylabel('Expected Return')
        ax.set_title('Risk-Return Analysis')
        ax.grid(True, alpha=0.3)
        
        return self.plot_to_base64(fig)
    
    def create_kpi_cards(self, metrics: Dict) -> List[Dict]:
        """
        Create KPI card data for Streamlit
        
        Args:
            metrics: Dictionary with financial metrics
            
        Returns:
            List of dictionaries with KPI data
        """
        kpi_cards = []
        
        # Define KPI mappings
        kpi_mappings = {
            'expected_return': {'label': 'Expected Return', 'format': '{:.2%}', 'color': 'green'},
            'volatility': {'label': 'Volatility', 'format': '{:.2%}', 'color': 'orange'},
            'sharpe_ratio': {'label': 'Sharpe Ratio', 'format': '{:.3f}', 'color': 'blue'},
            'beta': {'label': 'Beta', 'format': '{:.3f}', 'color': 'purple'},
            'alpha': {'label': 'Alpha', 'format': '{:.2%}', 'color': 'red'}
        }
        
        for key, value in metrics.items():
            if key in kpi_mappings:
                mapping = kpi_mappings[key]
                formatted_value = mapping['format'].format(value)
                kpi_cards.append({
                    'label': mapping['label'],
                    'value': formatted_value,
                    'color': mapping['color']
                })
        
        return kpi_cards