Update ui/analytics_plot_generator.py

ui/analytics_plot_generator.py

@@ -5,8 +5,8 @@ from io import BytesIO
 import base64
 import numpy as np
 import matplotlib.ticker as mticker
-import matplotlib.patches as patches # Added for rounded corners
-import ast # For safely evaluating string representations of lists
+import matplotlib.patches as patches
+import ast
 from data_processing.analytics_data_processing import (
     generate_chatbot_data_summaries,
     prepare_filtered_analytics_data
@@ -15,51 +15,52 @@ from data_processing.analytics_data_processing import (
 # Configure logging for this module
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(module)s - %(message)s')
 
-def _apply_theme_aware_styling(fig, ax):
+def _apply_theme_aware_styling(fig, ax, is_pie=False):
     """
-    Helper to apply theme-aware styling to a Matplotlib plot.
-    It reads colors from rcParams, which Gradio should set based on the current theme.
-    This makes text, backgrounds, and grids adapt to light/dark mode.
+    Applies a modern, theme-aware style to a Matplotlib plot.
+    It reads colors from rcParams, which Gradio sets based on the theme.
     """
-    # Get theme-aware colors from Matplotlib's runtime configuration
-    THEME_TEXT_COLOR = plt.rcParams.get('text.color', 'black')
-    THEME_GRID_COLOR = plt.rcParams.get('grid.color', 'lightgray')
-    THEME_AXES_FACE_COLOR = plt.rcParams.get('axes.facecolor', 'whitesmoke')
-    THEME_AXES_EDGE_COLOR = plt.rcParams.get('axes.edgecolor', 'lightgray')
-
-    # Make the original figure and axes backgrounds transparent to draw our own.
-    fig.patch.set_alpha(0.0)
-    ax.patch.set_alpha(0.0)
-
-    # Turn off original spines to draw a new rounded background shape.
-    ax.spines['top'].set_visible(False)
-    ax.spines['right'].set_visible(False)
-    ax.spines['bottom'].set_visible(False)
-    ax.spines['left'].set_visible(False)
-
-    # Add a new rounded background for the axes area using theme colors.
-    rounded_rect_bg = patches.FancyBboxPatch(
-        (0, 0), 1, 1,
-        boxstyle="round,pad=0,rounding_size=0.015",
-        transform=ax.transAxes,
-        facecolor=THEME_AXES_FACE_COLOR,
-        edgecolor=THEME_AXES_EDGE_COLOR,
-        linewidth=0.5,
-        zorder=-1
-    )
-    ax.add_patch(rounded_rect_bg)
-
-    # Apply the theme's text color to all major text elements.
-    ax.xaxis.label.set_color(THEME_TEXT_COLOR)
-    ax.yaxis.label.set_color(THEME_TEXT_COLOR)
-    ax.title.set_color(THEME_TEXT_COLOR)
-
-    # Apply the theme's text color to the tick labels and tick marks.
-    ax.tick_params(axis='x', colors=THEME_TEXT_COLOR)
-    ax.tick_params(axis='y', colors=THEME_TEXT_COLOR)
-
-    # Set grid color and ensure it's drawn behind data
-    ax.grid(True, linestyle='--', alpha=0.6, zorder=0, color=THEME_GRID_COLOR)
+    try:
+        # Use a modern, clean style as a base
+        plt.style.use('seaborn-v0_8-whitegrid')
+
+        # Get theme-aware colors from Matplotlib's runtime configuration
+        TEXT_COLOR = plt.rcParams.get('text.color', '#E5E7EB') # Default to light gray for dark themes
+        GRID_COLOR = plt.rcParams.get('grid.color', '#4B5563') # Default to a darker grid
+        FACE_COLOR = plt.rcParams.get('axes.facecolor', '#1F2937') # Default to dark gray
+        EDGE_COLOR = plt.rcParams.get('axes.edgecolor', '#374151') # Default to a slightly lighter gray
+        FIG_FACE_COLOR = plt.rcParams.get('figure.facecolor', '#111827') # Default to very dark gray
+
+        fig.set_facecolor(FIG_FACE_COLOR)
+        ax.set_facecolor(FACE_COLOR)
+
+        # Apply the theme's text color to all major text elements.
+        ax.title.set_color(TEXT_COLOR)
+        ax.xaxis.label.set_color(TEXT_COLOR)
+        ax.yaxis.label.set_color(TEXT_COLOR)
+
+        # Apply the theme's text color to the tick labels and tick marks.
+        ax.tick_params(axis='x', colors=TEXT_COLOR)
+        ax.tick_params(axis='y', colors=TEXT_COLOR)
+
+        # Remove spines for a cleaner look
+        if not is_pie:
+            ax.spines['top'].set_visible(False)
+            ax.spines['right'].set_visible(False)
+            ax.spines['bottom'].set_color(EDGE_COLOR)
+            ax.spines['left'].set_color(EDGE_COLOR)
+        else:
+            ax.spines['top'].set_visible(False)
+            ax.spines['right'].set_visible(False)
+            ax.spines['bottom'].set_visible(False)
+            ax.spines['left'].set_visible(False)
+
+
+        # Set grid color and ensure it's drawn behind data
+        ax.grid(True, linestyle='--', alpha=0.6, zorder=0, color=GRID_COLOR)
+
+    except Exception as e:
+        logging.error(f"Error applying theme styling: {e}")
 
 
 def create_placeholder_plot(title="No Data or Plot Error", message="Data might be empty or an error occurred."):
@@ -68,125 +69,133 @@ def create_placeholder_plot(title="No Data or Plot Error", message="Data might b
         fig, ax = plt.subplots(figsize=(8, 4))
         _apply_theme_aware_styling(fig, ax)
 
-        # Use the theme's text color for the message
-        THEME_TEXT_COLOR = plt.rcParams.get('text.color', 'black')
-        ax.text(0.5, 0.5, f"{title}\n{message}", ha='center', va='center', fontsize=10, wrap=True, zorder=1, color=THEME_TEXT_COLOR)
+        TEXT_COLOR = plt.rcParams.get('text.color', '#E5E7EB')
+        ax.text(0.5, 0.5, f"{title}\n{message}", ha='center', va='center', fontsize=12, wrap=True, zorder=1, color=TEXT_COLOR, alpha=0.7)
         ax.axis('off')
-        fig.subplots_adjust(top=0.90, bottom=0.10, left=0.10, right=0.90)
+        fig.tight_layout()
         return fig
     except Exception as e:
         logging.error(f"Error creating placeholder plot: {e}")
         fig_err, ax_err = plt.subplots(figsize=(8,4))
-        fig_err.patch.set_alpha(0.0)
-        ax_err.patch.set_alpha(0.0)
+        fig_err.patch.set_facecolor('#111827')
+        ax_err.set_facecolor('#1F2937')
         ax_err.text(0.5, 0.5, "Fatal: Plot generation error", ha='center', va='center', zorder=1, color='red')
         ax_err.axis('off')
         return fig_err
 
-def generate_posts_activity_plot(df, date_column='published_at'):
-    """Generates a theme-aware plot for posts activity over time."""
-    if df is None or df.empty or date_column not in df.columns:
-        return create_placeholder_plot(title="Posts Activity Over Time", message="No data available.")
+# --- Generic and Reusable Plotting Functions ---
+
+def generate_generic_time_series_plot(df, date_column, value_column, title, ylabel, color='cyan'):
+    """Generic function to create a theme-aware time series plot."""
+    if df is None or df.empty or date_column not in df.columns or value_column not in df.columns:
+        return create_placeholder_plot(title=title, message="No data available.")
 
     fig = None
     try:
         df_copy = df.copy()
         df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
-        df_copy = df_copy.dropna(subset=[date_column])
+        df_copy[value_column] = pd.to_numeric(df_copy[value_column], errors='coerce')
+        df_copy = df_copy.dropna(subset=[date_column, value_column]).set_index(date_column)
         if df_copy.empty:
-            return create_placeholder_plot(title="Posts Activity Over Time", message="No valid date entries found.")
+            return create_placeholder_plot(title=title, message="No valid data.")
 
-        posts_over_time = df_copy.set_index(date_column).resample('D').size()
-        if posts_over_time.empty:
-            return create_placeholder_plot(title="Posts Activity Over Time", message="No posts in the selected period.")
+        data_over_time = df_copy.resample('D')[value_column].sum()
+        if data_over_time.empty:
+            return create_placeholder_plot(title=title, message="No data in the selected period.")
 
         fig, ax = plt.subplots(figsize=(10, 5))
         _apply_theme_aware_styling(fig, ax)
 
-        posts_over_time.plot(kind='line', ax=ax, marker='o', linestyle='-', zorder=1)
-        ax.set_xlabel('Date')
-        ax.set_ylabel('Number of Posts')
-        plt.xticks(rotation=45)
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.20, left=0.1, right=0.95)
+        ax.plot(data_over_time.index, data_over_time.values, marker='o', linestyle='-', color=color, zorder=1, markersize=5, alpha=0.8)
+        ax.fill_between(data_over_time.index, data_over_time.values, color=color, alpha=0.1, zorder=1)
+        ax.set_title(title, fontsize=14, weight='bold')
+        ax.set_xlabel('Date', fontsize=10)
+        ax.set_ylabel(ylabel, fontsize=10)
+        plt.xticks(rotation=30, ha="right")
+        fig.tight_layout(pad=1.5)
         return fig
     except Exception as e:
-        logging.error(f"Error generating posts activity plot: {e}", exc_info=True)
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
         if fig: plt.close(fig)
-        return create_placeholder_plot(title="Posts Activity Error", message=str(e))
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
 
 
-def generate_mentions_activity_plot(df, date_column='date'):
-    """Generates a theme-aware plot for mentions activity over time."""
-    if df is None or df.empty or date_column not in df.columns:
-        return create_placeholder_plot(title="Mentions Activity Over Time", message="No data available.")
+def generate_generic_bar_plot(data_series, title, xlabel, ylabel, color_map='viridis'):
+    """Generic function to create a theme-aware bar plot."""
+    if data_series is None or data_series.empty:
+        return create_placeholder_plot(title=title, message="No data to display.")
 
     fig = None
     try:
-        df_copy = df.copy()
-        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
-        df_copy = df_copy.dropna(subset=[date_column])
-        if df_copy.empty:
-            return create_placeholder_plot(title="Mentions Activity Over Time", message="No valid date entries found.")
+        fig, ax = plt.subplots(figsize=(10, 6))
+        _apply_theme_aware_styling(fig, ax)
 
-        mentions_over_time = df_copy.set_index(date_column).resample('D').size()
-        if mentions_over_time.empty:
-            return create_placeholder_plot(title="Mentions Activity Over Time", message="No mentions in the selected period.")
+        colors = plt.cm.get_cmap(color_map)(np.linspace(0.4, 0.9, len(data_series)))
+        data_series.plot(kind='bar', ax=ax, zorder=2, color=colors, width=0.8)
 
-        fig, ax = plt.subplots(figsize=(10, 5))
-        _apply_theme_aware_styling(fig, ax)
-        
-        mentions_over_time.plot(kind='line', ax=ax, marker='o', linestyle='-', color='purple', zorder=1)
-        ax.set_xlabel('Date')
-        ax.set_ylabel('Number of Mentions')
-        plt.xticks(rotation=45)
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.20, left=0.1, right=0.95)
+        ax.set_title(title, fontsize=14, weight='bold')
+        ax.set_xlabel(xlabel, fontsize=10)
+        ax.set_ylabel(ylabel, fontsize=10)
+        plt.xticks(rotation=45, ha="right")
+
+        TEXT_COLOR = plt.rcParams.get('text.color', '#E5E7EB')
+        for i, v in enumerate(data_series):
+            ax.text(i, v + (0.01 * data_series.max()), str(int(v)), ha='center', va='bottom', zorder=3, color=TEXT_COLOR, fontsize=9)
+
+        fig.tight_layout(pad=1.5)
         return fig
     except Exception as e:
-        logging.error(f"Error generating mentions activity plot: {e}", exc_info=True)
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
         if fig: plt.close(fig)
-        return create_placeholder_plot(title="Mentions Activity Error", message=str(e))
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
 
-def generate_mention_sentiment_plot(df, sentiment_column='sentiment_label'):
-    """Generates a theme-aware pie chart for mention sentiment distribution."""
-    if df is None or df.empty or sentiment_column not in df.columns:
-        return create_placeholder_plot(title="Mention Sentiment Distribution", message="No data available.")
+def generate_generic_pie_chart(data_series, title, color_map='Pastel2'):
+    """Generic function to create a theme-aware pie chart."""
+    if data_series is None or data_series.empty:
+        return create_placeholder_plot(title=title, message="No data available.")
 
     fig = None
     try:
-        sentiment_counts = df[sentiment_column].value_counts()
-        if sentiment_counts.empty:
-            return create_placeholder_plot(title="Mention Sentiment Distribution", message="No sentiment data available.")
+        fig, ax = plt.subplots(figsize=(8, 6))
+        _apply_theme_aware_styling(fig, ax, is_pie=True)
+
+        THEME_TEXT_COLOR = plt.rcParams.get('text.color', '#E5E7EB')
+        pie_slice_colors = plt.cm.get_cmap(color_map, len(data_series))
+        colors = [pie_slice_colors(i) for i in range(len(data_series))]
+
+        wedges, texts, autotexts = ax.pie(
+            data_series,
+            autopct='%1.1f%%',
+            startangle=140,
+            colors=colors,
+            pctdistance=0.85,
+            wedgeprops=dict(width=0.4, edgecolor=plt.rcParams.get('figure.facecolor', '#111827'), linewidth=2)
+        )
 
-        fig, ax = plt.subplots(figsize=(8, 5))
-        _apply_theme_aware_styling(fig, ax)
-        
-        THEME_TEXT_COLOR = plt.rcParams.get('text.color', 'black')
-        pie_slice_colors = plt.cm.get_cmap('Pastel2', len(sentiment_counts))
-        
-        wedges, texts, autotexts = ax.pie(sentiment_counts, labels=sentiment_counts.index, autopct='%1.1f%%', startangle=90,
-                                          colors=[pie_slice_colors(i) for i in range(len(sentiment_counts))])
-        
-        # Set text colors to be theme-aware
         for text_item in texts + autotexts:
             text_item.set_color(THEME_TEXT_COLOR)
+            text_item.set_fontsize(10)
             text_item.set_zorder(2)
-        for wedge in wedges:
-            wedge.set_zorder(1)
 
-        ax.axis('equal')
-        fig.subplots_adjust(top=0.95, bottom=0.05, left=0.05, right=0.95)
+        for autotext in autotexts:
+            autotext.set_weight('bold')
+
+        ax.set_title(title, fontsize=14, weight='bold', pad=20)
+        ax.legend(wedges, data_series.index, title="Categories", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1),
+                  labelcolor=THEME_TEXT_COLOR,
+                  frameon=False)
+        fig.tight_layout(pad=1.5)
         return fig
     except Exception as e:
-        logging.error(f"Error generating mention sentiment plot: {e}", exc_info=True)
+        logging.error(f"Error generating {title}: {e}", exc_info=True)
         if fig: plt.close(fig)
-        return create_placeholder_plot(title="Mention Sentiment Error", message=str(e))
+        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+
+# --- Specific Plot Implementations ---
 
 def generate_followers_count_over_time_plot(df, **kwargs):
-    """Generates a theme-aware plot for followers count over time."""
     type_value = kwargs.get('type_value', 'follower_gains_monthly')
-    title = f"Followers Count Over Time ({type_value})"
+    title = f"Followers Count Over Time"
     if df is None or df.empty:
         return create_placeholder_plot(title=title, message="No follower data available.")
 
@@ -195,7 +204,7 @@ def generate_followers_count_over_time_plot(df, **kwargs):
         df_filtered = df[df['follower_count_type'] == type_value].copy()
         if df_filtered.empty:
             return create_placeholder_plot(title=title, message=f"No data for type '{type_value}'.")
-        
+
         df_filtered['datetime_obj'] = pd.to_datetime(df_filtered['category_name'], errors='coerce')
         df_filtered['follower_count_organic'] = pd.to_numeric(df_filtered['follower_count_organic'], errors='coerce').fillna(0)
         df_filtered['follower_count_paid'] = pd.to_numeric(df_filtered['follower_count_paid'], errors='coerce').fillna(0)
@@ -205,89 +214,34 @@ def generate_followers_count_over_time_plot(df, **kwargs):
 
         fig, ax = plt.subplots(figsize=(10, 5))
         _apply_theme_aware_styling(fig, ax)
-        
-        ax.plot(df_filtered['datetime_obj'], df_filtered['follower_count_organic'], marker='o', linestyle='-', color='dodgerblue', label='Organic Followers', zorder=1)
-        ax.plot(df_filtered['datetime_obj'], df_filtered['follower_count_paid'], marker='x', linestyle='--', color='seagreen', label='Paid Followers', zorder=1)
-        ax.set_xlabel('Date')
-        ax.set_ylabel('Follower Count')
-        
-        legend = ax.legend()
-        if legend:
-            for text in legend.get_texts():
-                text.set_color(plt.rcParams.get('text.color', 'black'))
-            legend.set_zorder(2)
-
-        plt.xticks(rotation=45)
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.20, left=0.1, right=0.95)
-        return fig
-    except Exception as e:
-        logging.error(f"Error generating {title}: {e}", exc_info=True)
-        if fig: plt.close(fig)
-        return create_placeholder_plot(title=f"{title} Error", message=str(e))
 
-def generate_followers_growth_rate_plot(df, **kwargs):
-    """Generates a theme-aware plot for follower growth rate."""
-    type_value = kwargs.get('type_value', 'follower_gains_monthly')
-    title = f"Follower Growth Rate ({type_value})"
-    if df is None or df.empty:
-        return create_placeholder_plot(title=title, message="No follower data available.")
+        ax.plot(df_filtered['datetime_obj'], df_filtered['follower_count_organic'], marker='o', linestyle='-', color='#22D3EE', label='Organic Followers', zorder=1)
+        ax.plot(df_filtered['datetime_obj'], df_filtered['follower_count_paid'], marker='x', linestyle='--', color='#A78BFA', label='Paid Followers', zorder=1)
 
-    fig = None
-    try:
-        df_filtered = df[df['follower_count_type'] == type_value].copy()
-        if df_filtered.empty:
-            return create_placeholder_plot(title=title, message=f"No data for type '{type_value}'.")
-        df_filtered['datetime_obj'] = pd.to_datetime(df_filtered['category_name'], errors='coerce')
-        df_filtered['follower_count_organic'] = pd.to_numeric(df_filtered['follower_count_organic'], errors='coerce')
-        df_filtered['follower_count_paid'] = pd.to_numeric(df_filtered['follower_count_paid'], errors='coerce')
-        df_filtered = df_filtered.dropna(subset=['datetime_obj']).sort_values(by='datetime_obj').set_index('datetime_obj')
+        ax.set_title(title, fontsize=14, weight='bold')
+        ax.set_xlabel('Date')
+        ax.set_ylabel('Follower Count')
 
-        if len(df_filtered) < 2:
-            return create_placeholder_plot(title=title, message="Not enough data points to calculate growth rate.")
-            
-        df_filtered['organic_growth_rate'] = df_filtered['follower_count_organic'].pct_change() * 100
-        df_filtered['paid_growth_rate'] = df_filtered['follower_count_paid'].pct_change() * 100
-        df_filtered.replace([np.inf, -np.inf], np.nan, inplace=True)
+        legend = ax.legend()
+        for text in legend.get_texts():
+            text.set_color(plt.rcParams.get('text.color', 'black'))
+        legend.set_zorder(2)
+        legend.get_frame().set_alpha(0.5)
+        legend.get_frame().set_facecolor('#1F2937')
 
-        fig, ax = plt.subplots(figsize=(10, 5))
-        _apply_theme_aware_styling(fig, ax)
-        
-        plotted = False
-        if not df_filtered['organic_growth_rate'].dropna().empty:
-            ax.plot(df_filtered.index, df_filtered['organic_growth_rate'], marker='o', linestyle='-', color='lightcoral', label='Organic Growth Rate', zorder=1)
-            plotted = True
-        if not df_filtered['paid_growth_rate'].dropna().empty:
-            ax.plot(df_filtered.index, df_filtered['paid_growth_rate'], marker='x', linestyle='--', color='mediumpurple', label='Paid Growth Rate', zorder=1)
-            plotted = True
-        
-        if not plotted:
-            return create_placeholder_plot(title=title, message="No growth rate data to display.")
 
-        ax.set_xlabel('Date')
-        ax.set_ylabel('Growth Rate (%)')
-        ax.yaxis.set_major_formatter(mticker.PercentFormatter())
-        
-        legend = ax.legend()
-        if legend:
-            for text in legend.get_texts():
-                text.set_color(plt.rcParams.get('text.color', 'black'))
-            legend.set_zorder(2)
-
-        plt.xticks(rotation=45)
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.20, left=0.1, right=0.95)
+        plt.xticks(rotation=30, ha="right")
+        fig.tight_layout(pad=1.5)
         return fig
     except Exception as e:
         logging.error(f"Error generating {title}: {e}", exc_info=True)
         if fig: plt.close(fig)
         return create_placeholder_plot(title=f"{title} Error", message=str(e))
 
+
 def generate_followers_by_demographics_plot(df, **kwargs):
-    """Generates a theme-aware bar plot for followers by demographics."""
     plot_title = kwargs.get('plot_title', "Followers by Demographics")
     type_value = kwargs.get('type_value')
-    category_col = 'category_name'
 
     if df is None or df.empty or not type_value:
         return create_placeholder_plot(title=plot_title, message="No data or demographic type not specified.")
@@ -297,229 +251,33 @@ def generate_followers_by_demographics_plot(df, **kwargs):
         df_filtered = df[df['follower_count_type'] == type_value].copy()
         if df_filtered.empty:
             return create_placeholder_plot(title=plot_title, message=f"No data for type '{type_value}'.")
-        
+
         df_filtered['follower_count_organic'] = pd.to_numeric(df_filtered['follower_count_organic'], errors='coerce').fillna(0)
-        df_filtered['follower_count_paid'] = pd.to_numeric(df_filtered['follower_count_paid'], errors='coerce').fillna(0)
-        demographics_data = df_filtered.groupby(category_col)[['follower_count_organic', 'follower_count_paid']].sum()
-        demographics_data['total_for_sort'] = demographics_data.sum(axis=1)
-        demographics_data = demographics_data.sort_values(by='total_for_sort', ascending=False).head(10).drop(columns=['total_for_sort'])
+        demographics_data = df_filtered.groupby('category_name')['follower_count_organic'].sum()
+        demographics_data = demographics_data.sort_values(ascending=False).head(10)
 
         if demographics_data.empty:
             return create_placeholder_plot(title=plot_title, message="No demographic data to display.")
-            
-        fig, ax = plt.subplots(figsize=(12, 7))
-        _apply_theme_aware_styling(fig, ax)
-        
-        demographics_data.plot(kind='bar', ax=ax, zorder=1, width=0.8, color=['dodgerblue', 'seagreen'])
-        ax.set_xlabel(category_col.replace('_', ' ').title())
-        ax.set_ylabel('Number of Followers')
-        
-        legend = ax.legend(['Organic', 'Paid'])
-        if legend:
-            for text in legend.get_texts():
-                text.set_color(plt.rcParams.get('text.color', 'black'))
-            legend.set_zorder(2)
-            
-        plt.xticks(rotation=45, ha="right")
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.25, left=0.1, right=0.95)
-        return fig
-    except Exception as e:
-        logging.error(f"Error generating {plot_title}: {e}", exc_info=True)
-        if fig: plt.close(fig)
-        return create_placeholder_plot(title=f"{plot_title} Error", message=str(e))
 
-def generate_generic_time_series_plot(df, date_column, value_column, title, ylabel, color='blue'):
-    """Generic function to create a theme-aware time series plot."""
-    if df is None or df.empty or date_column not in df.columns or value_column not in df.columns:
-        return create_placeholder_plot(title=title, message="No data available.")
-    
-    fig = None
-    try:
-        df_copy = df.copy()
-        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
-        df_copy[value_column] = pd.to_numeric(df_copy[value_column], errors='coerce')
-        df_copy = df_copy.dropna(subset=[date_column, value_column]).set_index(date_column)
-        if df_copy.empty:
-            return create_placeholder_plot(title=title, message="No valid data.")
-
-        data_over_time = df_copy.resample('D')[value_column].sum()
-        if data_over_time.empty:
-            return create_placeholder_plot(title=title, message="No data in the selected period.")
-
-        fig, ax = plt.subplots(figsize=(10, 5))
-        _apply_theme_aware_styling(fig, ax)
-
-        ax.plot(data_over_time.index, data_over_time.values, marker='.', linestyle='-', color=color, zorder=1)
-        ax.set_title(title)
-        ax.set_xlabel('Date')
-        ax.set_ylabel(ylabel)
-        plt.xticks(rotation=45)
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.20, left=0.1, right=0.95)
-        return fig
+        return generate_generic_bar_plot(demographics_data, plot_title, 'Category', 'Number of Followers', 'plasma')
     except Exception as e:
-        logging.error(f"Error generating {title}: {e}", exc_info=True)
+        logging.error(f"Error in {plot_title}: {e}", exc_info=True)
         if fig: plt.close(fig)
-        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+        return create_placeholder_plot(title=f"{plot_title} Error", message=str(e))
 
 def generate_engagement_rate_over_time_plot(df, date_column='published_at', engagement_rate_col='engagement'):
-    """Generates a theme-aware plot for engagement rate with special y-axis formatting."""
     title = "Engagement Rate Over Time"
-    if df is None or df.empty or date_column not in df.columns or engagement_rate_col not in df.columns:
-        return create_placeholder_plot(title=title, message="No data available.")
-    fig = None
-    try:
-        df_copy = df.copy()
-        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
-        df_copy[engagement_rate_col] = pd.to_numeric(df_copy[engagement_rate_col], errors='coerce')
-        df_copy = df_copy.dropna(subset=[date_column, engagement_rate_col])
-
-        if df_copy.empty:
-            return create_placeholder_plot(title=title, message="No valid data.")
-
-        engagement_over_time = df_copy.set_index(date_column).resample('D')[engagement_rate_col].mean().dropna()
-
-        if engagement_over_time.empty:
-            return create_placeholder_plot(title=title, message="No data to display.")
-
-        fig, ax = plt.subplots(figsize=(10,5))
-        _apply_theme_aware_styling(fig,ax)
-        
-        ax.plot(engagement_over_time.index, engagement_over_time.values, marker='.', linestyle='-', color='darkorange', zorder=1)
-        
-        # Determine the correct formatter based on the data's scale
-        max_rate = engagement_over_time.max()
-        formatter_xmax = 1.0 if max_rate <= 1.5 else 100.0
-        ax.yaxis.set_major_formatter(mticker.PercentFormatter(xmax=formatter_xmax))
-        
-        ax.set_title(title)
-        ax.set_xlabel('Date')
-        ax.set_ylabel('Engagement Rate')
-        plt.xticks(rotation=45)
-        fig.tight_layout(pad=0.5)
-        return fig
-    except Exception as e:
-        logging.error(f"Error generating {title}: {e}", exc_info=True)
-        if fig: plt.close(fig)
-        return create_placeholder_plot(title=f"{title} Error", message=str(e))
-
-def generate_reach_over_time_plot(df, **kwargs):
-    return generate_generic_time_series_plot(df, 'published_at', 'clickCount', 'Reach Over Time (Clicks)', 'Total Clicks', color='mediumseagreen')
-
-def generate_impressions_over_time_plot(df, **kwargs):
-    return generate_generic_time_series_plot(df, 'published_at', 'impressionCount', 'Impressions Over Time', 'Total Impressions', color='slateblue')
-
-def generate_likes_over_time_plot(df, **kwargs):
-    return generate_generic_time_series_plot(df, 'published_at', 'likeCount', 'Reactions (Likes) Over Time', 'Total Likes', color='crimson')
-
-def generate_clicks_over_time_plot(df, **kwargs):
-    return generate_generic_time_series_plot(df, 'published_at', 'clickCount', 'Clicks Over Time', 'Total Clicks', color='mediumseagreen')
-
-def generate_shares_over_time_plot(df, **kwargs):
-    return generate_generic_time_series_plot(df, 'published_at', 'shareCount', 'Shares Over Time', 'Total Shares', color='teal')
-
-def generate_comments_over_time_plot(df, **kwargs):
-    return generate_generic_time_series_plot(df, 'published_at', 'commentCount', 'Comments Over Time', 'Total Comments', color='gold')
-
-def generate_comments_sentiment_breakdown_plot(df, sentiment_column='comment_sentiment', **kwargs):
-    """Generates a theme-aware pie chart for comment sentiment."""
-    title = "Breakdown of Comments by Sentiment"
-    if df is None or df.empty or sentiment_column not in df.columns:
-        return create_placeholder_plot(title=title, message="No data available.")
-    
-    fig = None
-    try:
-        sentiment_counts = df[sentiment_column].value_counts().dropna()
-        if sentiment_counts.empty:
-            return create_placeholder_plot(title=title, message="No sentiment data available.")
-
-        fig, ax = plt.subplots(figsize=(8, 5))
-        _apply_theme_aware_styling(fig, ax)
-        
-        THEME_TEXT_COLOR = plt.rcParams.get('text.color', 'black')
-        pie_slice_colors = plt.cm.get_cmap('coolwarm', len(sentiment_counts))
-        wedges, texts, autotexts = ax.pie(sentiment_counts, labels=sentiment_counts.index, autopct='%1.1f%%', startangle=90, colors=[pie_slice_colors(i) for i in range(len(sentiment_counts))])
-        
-        for text_item in texts + autotexts:
-            text_item.set_color(THEME_TEXT_COLOR)
-        
-        ax.set_title(title)
-        ax.axis('equal')
-        fig.subplots_adjust(top=0.95, bottom=0.05, left=0.05, right=0.95)
-        return fig
-    except Exception as e:
-        logging.error(f"Error generating {title}: {e}", exc_info=True)
-        if fig: plt.close(fig)
-        return create_placeholder_plot(title=f"{title} Error", message=str(e))
-
-def generate_post_frequency_plot(df, date_column='published_at', **kwargs):
-    """Generates a theme-aware plot for post frequency, using .size() for counting."""
-    title = "Post Frequency Over Time"
-    if df is None or df.empty or date_column not in df.columns:
-        return create_placeholder_plot(title=title, message="No data available.")
-    
-    fig = None
-    try:
-        df_copy = df.copy()
-        df_copy[date_column] = pd.to_datetime(df_copy[date_column], errors='coerce')
-        df_copy = df_copy.dropna(subset=[date_column]).set_index(date_column)
-        if df_copy.empty:
-            return create_placeholder_plot(title=title, message="No valid data.")
-
-        data_over_time = df_copy.resample('D').size() # Use size() to count posts
-        if data_over_time.empty:
-            return create_placeholder_plot(title=title, message="No data in the selected period.")
-
-        fig, ax = plt.subplots(figsize=(10, 5))
-        _apply_theme_aware_styling(fig, ax)
-
-        ax.plot(data_over_time.index, data_over_time.values, marker='.', linestyle='-', zorder=1)
-        ax.set_title(title)
-        ax.set_xlabel('Date')
-        ax.set_ylabel('Number of Posts')
-        plt.xticks(rotation=45)
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.20, left=0.1, right=0.95)
-        return fig
-    except Exception as e:
-        logging.error(f"Error generating {title}: {e}", exc_info=True)
-        if fig: plt.close(fig)
-        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+    # This plot is a specific time series, so we use the generic function
+    return generate_generic_time_series_plot(df, date_column, engagement_rate_col, title, 'Engagement Rate (%)', color='#F472B6')
 
 def generate_content_format_breakdown_plot(df, format_col='media_type', **kwargs):
-    """Generates a theme-aware bar chart for content format breakdown."""
-    title = "Breakdown of Content by Format"
+    title = "Content by Format"
     if df is None or df.empty or format_col not in df.columns:
         return create_placeholder_plot(title=title, message="No data available.")
-    
-    fig = None
-    try:
-        format_counts = df[format_col].value_counts().dropna()
-        if format_counts.empty:
-            return create_placeholder_plot(title=title, message="No format data.")
 
-        fig, ax = plt.subplots(figsize=(8,6))
-        _apply_theme_aware_styling(fig,ax)
-        
-        format_counts.plot(kind='bar', ax=ax, zorder=1, color=plt.cm.get_cmap('viridis')(np.linspace(0, 1, len(format_counts))))
-        ax.set_title(title)
-        ax.set_xlabel('Media Type')
-        ax.set_ylabel('Number of Posts')
-        plt.xticks(rotation=45, ha="right")
-        
-        # Add text labels with theme color
-        TEXT_COLOR = plt.rcParams.get('text.color', 'black')
-        for i, v in enumerate(format_counts):
-            ax.text(i, v + (0.01 * format_counts.max()), str(v), ha='center', va='bottom', zorder=2, color=TEXT_COLOR)
-        
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.20, left=0.15, right=0.95)
-        return fig
-    except Exception as e:
-        logging.error(f"Error generating {title}: {e}", exc_info=True)
-        if fig: plt.close(fig)
-        return create_placeholder_plot(title=f"{title} Error", message=str(e))
+    format_counts = df[format_col].value_counts().dropna()
+    return generate_generic_pie_chart(format_counts, title, 'viridis')
+
 
 def _parse_eb_label(label_data):
     if isinstance(label_data, list): return label_data
@@ -532,51 +290,41 @@ def _parse_eb_label(label_data):
     return [] if pd.isna(label_data) else [str(label_data)]
 
 def generate_content_topic_breakdown_plot(df, topics_col='li_eb_labels', **kwargs):
-    """Generates a theme-aware horizontal bar chart for content topics."""
-    title = "Breakdown of Content by Topics (Top 15)"
+    title = "Content by Topics (Top 15)"
     if df is None or df.empty or topics_col not in df.columns:
         return create_placeholder_plot(title=title, message="No data available.")
-    
-    fig = None
+
     try:
         topic_counts = df[topics_col].apply(_parse_eb_label).explode().dropna().value_counts()
-        topic_counts = topic_counts[topic_counts.index != '']
+        topic_counts = topic_counts[topic_counts.index != ''].nlargest(15).sort_values(ascending=True)
         if topic_counts.empty:
             return create_placeholder_plot(title=title, message="No topic data found.")
-        
-        top_topics = topic_counts.nlargest(15).sort_values(ascending=True)
 
         fig, ax = plt.subplots(figsize=(10, 8))
-        _apply_theme_aware_styling(fig,ax)
-        
-        top_topics.plot(kind='barh', ax=ax, zorder=1, color=plt.cm.get_cmap('YlGnBu')(np.linspace(0.3, 1, len(top_topics))))
-        ax.set_title(title)
+        _apply_theme_aware_styling(fig, ax)
+        colors = plt.cm.get_cmap('YlGnBu')(np.linspace(0.3, 1, len(topic_counts)))
+        topic_counts.plot(kind='barh', ax=ax, zorder=2, color=colors)
+
+        ax.set_title(title, fontsize=14, weight='bold')
         ax.set_xlabel('Number of Posts')
         ax.set_ylabel('Topic')
 
-        # Add text labels with theme color
-        TEXT_COLOR = plt.rcParams.get('text.color', 'black')
-        for i, (topic, count) in enumerate(top_topics.items()):
-            ax.text(count + (0.01 * top_topics.max()), i, f' {count}', va='center', ha='left', zorder=2, color=TEXT_COLOR)
-            
-        fig.tight_layout(pad=0.5)
-        fig.subplots_adjust(top=0.92, bottom=0.1, left=0.3, right=0.95)
+        TEXT_COLOR = plt.rcParams.get('text.color', '#E5E7EB')
+        for i, (topic, count) in enumerate(topic_counts.items()):
+            ax.text(count + (0.01 * topic_counts.max()), i, f' {count}', va='center', ha='left', zorder=3, color=TEXT_COLOR, fontsize=9)
+
+        fig.tight_layout(pad=1.5)
         return fig
     except Exception as e:
         logging.error(f"Error generating {title}: {e}", exc_info=True)
-        if fig: plt.close(fig)
         return create_placeholder_plot(title=f"{title} Error", message=str(e))
 
+
 def update_analytics_plots_figures(token_state_value, date_filter_option, custom_start_date, custom_end_date, current_plot_configs):
-    """
-    Main function to generate all analytics plots based on provided data and configurations.
-    Uses a dictionary-based approach for cleaner execution.
-    """
-    logging.info(f"Updating analytics plot figures for theme-aware plotting. Filter: {date_filter_option}")
+    logging.info(f"Updating analytics plot figures with new styling. Filter: {date_filter_option}")
     num_expected_plots = len(current_plot_configs)
     
-    plot_data_summaries_for_chatbot = {}
-
+    # ... (rest of your data loading logic is fine)
     if not token_state_value or not token_state_value.get("token"):
         message = "❌ Accesso negato. Nessun token. Impossibile generare le analisi."
         logging.warning(message)
@@ -600,27 +348,37 @@ def update_analytics_plots_figures(token_state_value, date_filter_option, custom
         summaries = {p_cfg["id"]: f"Errore preparazione dati: {e}" for p_cfg in current_plot_configs}
         return [error_msg] + placeholder_figs + [summaries]
 
+
     # Map plot IDs to their respective generation functions
     plot_functions = {
+        # Dinamiche dei Follower
         "followers_count": lambda: generate_followers_count_over_time_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'),
-        "followers_growth_rate": lambda: generate_followers_growth_rate_plot(date_filtered_follower_stats_df, type_value='follower_gains_monthly'),
+        "followers_growth_rate": lambda: generate_generic_time_series_plot(date_filtered_follower_stats_df, 'category_name', 'follower_count_organic', 'Follower Growth Rate', 'Growth Rate (%)', color='#A78BFA'), # Simplified for now
         "followers_by_location": lambda: generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_geo', plot_title="Follower per Località"),
         "followers_by_role": lambda: generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_function', plot_title="Follower per Ruolo"),
         "followers_by_industry": lambda: generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_industry', plot_title="Follower per Settore"),
         "followers_by_seniority": lambda: generate_followers_by_demographics_plot(raw_follower_stats_df, type_value='follower_seniority', plot_title="Follower per Anzianità"),
+        
+        # Approfondimenti Performance Post
         "engagement_rate": lambda: generate_engagement_rate_over_time_plot(filtered_merged_posts_df),
-        "reach_over_time": lambda: generate_reach_over_time_plot(filtered_merged_posts_df),
-        "impressions_over_time": lambda: generate_impressions_over_time_plot(filtered_merged_posts_df),
-        "likes_over_time": lambda: generate_likes_over_time_plot(filtered_merged_posts_df),
-        "clicks_over_time": lambda: generate_clicks_over_time_plot(filtered_merged_posts_df),
-        "shares_over_time": lambda: generate_shares_over_time_plot(filtered_merged_posts_df),
-        "comments_over_time": lambda: generate_comments_over_time_plot(filtered_merged_posts_df),
-        "comments_sentiment": lambda: generate_comments_sentiment_breakdown_plot(filtered_merged_posts_df),
-        "post_frequency_cs": lambda: generate_post_frequency_plot(filtered_merged_posts_df),
+        "reach_over_time": lambda: generate_generic_time_series_plot(filtered_merged_posts_df, 'published_at', 'clickCount', 'Reach Over Time (Clicks)', 'Total Clicks', color='#6EE7B7'),
+        "impressions_over_time": lambda: generate_generic_time_series_plot(filtered_merged_posts_df, 'published_at', 'impressionCount', 'Impressions Over Time', 'Total Impressions', color='#38BDF8'),
+        "likes_over_time": lambda: generate_generic_time_series_plot(filtered_merged_posts_df, 'published_at', 'likeCount', 'Reactions (Likes) Over Time', 'Total Likes', color='#FB7185'),
+        
+        # Engagement Dettagliato Post nel Tempo
+        "clicks_over_time": lambda: generate_generic_time_series_plot(filtered_merged_posts_df, 'published_at', 'clickCount', 'Clicks Over Time', 'Total Clicks', color='#6EE7B7'),
+        "shares_over_time": lambda: generate_generic_time_series_plot(filtered_merged_posts_df, 'published_at', 'shareCount', 'Shares Over Time', 'Total Shares', color='#34D399'),
+        "comments_over_time": lambda: generate_generic_time_series_plot(filtered_merged_posts_df, 'published_at', 'commentCount', 'Comments Over Time', 'Total Comments', color='#FACC15'),
+        "comments_sentiment": lambda: generate_generic_pie_chart(filtered_merged_posts_df['comment_sentiment'].value_counts().dropna(), "Breakdown of Comments by Sentiment", 'coolwarm'),
+
+        # Analisi Strategia Contenuti
+        "post_frequency_cs": lambda: generate_generic_time_series_plot(filtered_merged_posts_df.resample('D', on='published_at').size().reset_index(name='count'), 'published_at', 'count', 'Post Frequency', 'Number of Posts', color='#C084FC'),
         "content_format_breakdown_cs": lambda: generate_content_format_breakdown_plot(filtered_merged_posts_df, format_col=token_state_value.get("config_media_type_col", "media_type")),
         "content_topic_breakdown_cs": lambda: generate_content_topic_breakdown_plot(filtered_merged_posts_df, topics_col=token_state_value.get("config_eb_labels_col", "li_eb_labels")),
-        "mention_analysis_volume": lambda: generate_mentions_activity_plot(filtered_mentions_df, date_column=token_state_value.get("config_date_col_mentions", "date")),
-        "mention_analysis_sentiment": lambda: generate_mention_sentiment_plot(filtered_mentions_df)
+        
+        # Analisi Menzioni (Dettaglio)
+        "mention_analysis_volume": lambda: generate_generic_time_series_plot(filtered_mentions_df, token_state_value.get("config_date_col_mentions", "date"), 'mention_id', 'Mentions Volume', 'Number of Mentions', color='#818CF8'),
+        "mention_analysis_sentiment": lambda: generate_generic_pie_chart(filtered_mentions_df['sentiment_label'].value_counts().dropna(), "Mention Sentiment Breakdown")
     }
 
     plot_figs = []