Update src/streamlit_app.py

src/streamlit_app.py

@@ -174,10 +174,14 @@ class ApifyService:
     
     def fetch_account_tweets(self, username: str, since: str, until: str) -> Tuple[List[Dict], str]:
         """Fetch tweets posted by a specific account."""
+        # Handle both simple date (YYYY-MM-DD) and full timestamp (YYYY-MM-DD_HH:MM:SS) formats
+        since_formatted = f"{since}_UTC" if "_" in since else f"{since}_00:00:00_UTC"
+        until_formatted = f"{until}_UTC" if "_" in until else f"{until}_23:59:59_UTC"
+        
         run_input = {
-            "from": username,
-            "since": f"{since}_00:00:00_UTC",
-            "until": f"{until}_23:59:59_UTC",
+            "from": username.strip(),
+            "since": since_formatted,
+            "until": until_formatted,
             "queryType": "Latest",
             "include:nativeretweets": True,
         }
@@ -190,10 +194,14 @@ class ApifyService:
     
     def fetch_account_comments(self, username: str, since: str, until: str) -> Tuple[List[Dict], str]:
         """Fetch comments/replies directed to a specific account."""
+        # Handle both simple date (YYYY-MM-DD) and full timestamp (YYYY-MM-DD_HH:MM:SS) formats
+        since_formatted = f"{since}_UTC" if "_" in since else f"{since}_00:00:00_UTC"
+        until_formatted = f"{until}_UTC" if "_" in until else f"{until}_23:59:59_UTC"
+        
         run_input = {
-            "to": username,
-            "since": f"{since}_00:00:00_UTC",
-            "until": f"{until}_23:59:59_UTC",
+            "to": username.strip(),
+            "since": since_formatted,
+            "until": until_formatted,
             "queryType": "Latest",
         }
         
@@ -256,7 +264,7 @@ class GeminiService:
 class TweetDataProcessor:
     """Processes raw tweet data into structured format."""
     
-    def process_tweets(self, raw_data: List[Dict[str, Any]]) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    def process_tweets(self, raw_data: List[Dict[str, Any]], target_username: str = None) -> Tuple[pd.DataFrame, Dict[str, Any]]:
         """Transform raw API data into clean DataFrame and metrics."""
         processed_data = []
         hashtags_counter = Counter()
@@ -268,7 +276,7 @@ class TweetDataProcessor:
         
         for item in raw_data:
             try:
-                processed_tweet = self._process_single_tweet(item, hashtags_counter, mentions_counter, all_author_data)
+                processed_tweet = self._process_single_tweet(item, hashtags_counter, mentions_counter, all_author_data, target_username)
                 if processed_tweet:
                     processed_data.append(processed_tweet)
                 else:
@@ -288,10 +296,16 @@ class TweetDataProcessor:
             st.warning(f"⚠️ {error_count} items had processing errors")
         
         # Extract best account details
-        account_details = self._extract_best_account_details(all_author_data)
+        account_details = self._extract_best_account_details(all_author_data, target_username)
         
-        # Create DataFrame and metrics
+        # Create DataFrame and calculate engagement metrics from tweet data
         df = pd.DataFrame(processed_data)
+        engagement_metrics = self._calculate_engagement_metrics(df, target_username)
+        
+        # Add engagement metrics to account_details
+        if account_details:
+            account_details.update(engagement_metrics)
+        
         metrics = {
             "top_hashtags": hashtags_counter.most_common(5),
             "top_mentions": mentions_counter.most_common(5),
@@ -300,6 +314,193 @@ class TweetDataProcessor:
         
         return df, metrics
     
+    def _calculate_engagement_metrics(self, df: pd.DataFrame, target_username: str = None) -> Dict:
+        """Calculate comprehensive engagement metrics from tweet data."""
+        if df.empty:
+            return self._get_empty_metrics()
+        
+        # Filter to only tweets from the target user if specified
+        if target_username:
+            user_tweets = df[df['Username'].str.lower() == target_username.lower()]
+        else:
+            user_tweets = df
+        
+        if user_tweets.empty:
+            return self._get_empty_metrics()
+        
+        # Basic engagement totals
+        likes_count = user_tweets['Likes'].sum() if 'Likes' in user_tweets.columns else 0
+        views_count = user_tweets['Views'].sum() if 'Views' in user_tweets.columns else 0
+        reply_count = user_tweets['Replies'].sum() if 'Replies' in user_tweets.columns else 0
+        repost_count = user_tweets['Retweets'].sum() if 'Retweets' in user_tweets.columns else 0
+        
+        tweet_count = len(user_tweets)
+        
+        # Content quality metrics
+        avg_likes_per_tweet = likes_count / tweet_count if tweet_count > 0 else 0
+        avg_views_per_tweet = views_count / tweet_count if tweet_count > 0 else 0
+        avg_engagement_rate = ((likes_count + repost_count) / views_count * 100) if views_count > 0 else 0
+        
+        # Content length analysis
+        if 'Text' in user_tweets.columns:
+            text_lengths = user_tweets['Text'].astype(str).str.len()
+            avg_tweet_length = text_lengths.mean()
+            longest_tweet_length = text_lengths.max()
+            shortest_tweet_length = text_lengths.min()
+        else:
+            avg_tweet_length = longest_tweet_length = shortest_tweet_length = 0
+        
+        # Media usage metrics
+        if 'Has_Media' in user_tweets.columns:
+            tweets_with_media = user_tweets['Has_Media'].sum()
+            media_usage_percentage = (tweets_with_media / tweet_count * 100) if tweet_count > 0 else 0
+            
+            # Media effectiveness
+            media_tweets = user_tweets[user_tweets['Has_Media'] == True]
+            no_media_tweets = user_tweets[user_tweets['Has_Media'] == False]
+            
+            avg_likes_with_media = media_tweets['Likes'].mean() if len(media_tweets) > 0 else 0
+            avg_likes_without_media = no_media_tweets['Likes'].mean() if len(no_media_tweets) > 0 else 0
+        else:
+            tweets_with_media = media_usage_percentage = 0
+            avg_likes_with_media = avg_likes_without_media = 0
+        
+        # Hashtag and mention analysis
+        if 'Hashtags' in user_tweets.columns:
+            # Count hashtags from the Hashtags field (comma-separated string)
+            hashtag_counts = user_tweets['Hashtags'].astype(str).apply(lambda x: len([h.strip() for h in x.split(',') if h.strip()]))
+            total_hashtags_used = hashtag_counts.sum()
+            avg_hashtags_per_tweet = hashtag_counts.mean()
+            tweets_with_hashtags_percentage = ((hashtag_counts > 0).sum() / tweet_count * 100) if tweet_count > 0 else 0
+        elif 'Hashtag_Count' in user_tweets.columns:
+            # Fallback to Hashtag_Count if available
+            total_hashtags_used = user_tweets['Hashtag_Count'].sum()
+            avg_hashtags_per_tweet = user_tweets['Hashtag_Count'].mean()
+            tweets_with_hashtags_percentage = ((user_tweets['Hashtag_Count'] > 0).sum() / tweet_count * 100) if tweet_count > 0 else 0
+        else:
+            total_hashtags_used = avg_hashtags_per_tweet = tweets_with_hashtags_percentage = 0
+        
+        if 'Mentions' in user_tweets.columns:
+            # Count mentions from the Mentions field (comma-separated string)
+            mention_counts = user_tweets['Mentions'].astype(str).apply(lambda x: len([m.strip() for m in x.split(',') if m.strip()]))
+            total_mentions_used = mention_counts.sum()
+            avg_mentions_per_tweet = mention_counts.mean()
+        elif 'Mention_Count' in user_tweets.columns:
+            # Fallback to Mention_Count if available
+            total_mentions_used = user_tweets['Mention_Count'].sum()
+            avg_mentions_per_tweet = user_tweets['Mention_Count'].mean()
+        else:
+            total_mentions_used = avg_mentions_per_tweet = 0
+        
+        # Timing and activity patterns
+        if 'Hour' in user_tweets.columns:
+            most_active_hour = user_tweets['Hour'].mode().values[0] if len(user_tweets['Hour'].mode()) > 0 else 0
+            hourly_distribution = user_tweets['Hour'].value_counts().head(3).to_dict()
+        else:
+            most_active_hour = 0
+            hourly_distribution = {}
+        
+        if 'Day_of_Week' in user_tweets.columns:
+            most_active_day = user_tweets['Day_of_Week'].mode().values[0] if len(user_tweets['Day_of_Week'].mode()) > 0 else "Unknown"
+        else:
+            most_active_day = "Unknown"
+        
+        # Performance metrics
+        if 'Likes' in user_tweets.columns and not user_tweets.empty:
+            highest_likes = user_tweets['Likes'].max()
+            top_tweet_idx = user_tweets['Likes'].idxmax()
+            top_tweet_text = user_tweets.loc[top_tweet_idx, 'Text'][:100] + "..." if 'Text' in user_tweets.columns else ""
+            top_tweet_url = user_tweets.loc[top_tweet_idx, 'URL'] if 'URL' in user_tweets.columns else ""
+            
+            # Viral content (top 10% threshold)
+            viral_threshold = user_tweets['Likes'].quantile(0.9)
+            viral_tweets_count = (user_tweets['Likes'] > viral_threshold).sum()
+            viral_content_percentage = (viral_tweets_count / tweet_count * 100) if tweet_count > 0 else 0
+        else:
+            highest_likes = viral_tweets_count = viral_content_percentage = 0
+            top_tweet_text = top_tweet_url = ""
+        
+        # Audience engagement ratios
+        like_to_view_ratio = (likes_count / views_count * 100) if views_count > 0 else 0
+        retweet_to_like_ratio = (repost_count / likes_count * 100) if likes_count > 0 else 0
+        reply_to_like_ratio = (reply_count / likes_count * 100) if likes_count > 0 else 0
+        
+        # Engagement score (weighted: likes=1, retweets=2, replies=3)
+        total_engagement = likes_count + repost_count + reply_count
+        engagement_score = (likes_count * 1 + repost_count * 2 + reply_count * 3) / tweet_count if tweet_count > 0 else 0
+        
+        return {
+            # Basic metrics
+            "likes_count": int(likes_count),
+            "views_count": int(views_count),
+            "reply_count": int(reply_count),
+            "repost_count": int(repost_count),
+            
+            # Content quality metrics
+            "avg_likes_per_tweet": round(avg_likes_per_tweet, 1),
+            "avg_views_per_tweet": round(avg_views_per_tweet, 1),
+            "avg_engagement_rate": round(avg_engagement_rate, 2),
+            "avg_tweet_length": round(avg_tweet_length, 1),
+            "longest_tweet_length": int(longest_tweet_length),
+            "shortest_tweet_length": int(shortest_tweet_length),
+            
+            # Media usage metrics
+            "tweets_with_media_count": int(tweets_with_media),
+            "media_usage_percentage": round(media_usage_percentage, 1),
+            "avg_likes_with_media": round(avg_likes_with_media, 1),
+            "avg_likes_without_media": round(avg_likes_without_media, 1),
+            
+            # Hashtag and mention metrics
+            "total_hashtags_used": int(total_hashtags_used),
+            "avg_hashtags_per_tweet": round(avg_hashtags_per_tweet, 1),
+            "tweets_with_hashtags_percentage": round(tweets_with_hashtags_percentage, 1),
+            "total_mentions_used": int(total_mentions_used),
+            "avg_mentions_per_tweet": round(avg_mentions_per_tweet, 1),
+            
+            # Activity patterns
+            "most_active_hour": int(most_active_hour),
+            "most_active_day": str(most_active_day),
+            "top_activity_hours": list(hourly_distribution.keys())[:3],
+            
+            # Performance metrics
+            "highest_likes": int(highest_likes),
+            "top_tweet_text": str(top_tweet_text),
+            "top_tweet_url": str(top_tweet_url),
+            "viral_tweets_count": int(viral_tweets_count),
+            "viral_content_percentage": round(viral_content_percentage, 1),
+            
+            # Engagement ratios
+            "like_to_view_ratio": round(like_to_view_ratio, 2),
+            "retweet_to_like_ratio": round(retweet_to_like_ratio, 2),
+            "reply_to_like_ratio": round(reply_to_like_ratio, 2),
+            "engagement_score": round(engagement_score, 1),
+            "total_engagement": int(total_engagement),
+        }
+    
+    def _get_empty_metrics(self) -> Dict:
+        """Return empty metrics structure."""
+        return {
+            # Basic metrics
+            "likes_count": 0, "views_count": 0, "reply_count": 0, "repost_count": 0,
+            # Content quality metrics
+            "avg_likes_per_tweet": 0, "avg_views_per_tweet": 0, "avg_engagement_rate": 0,
+            "avg_tweet_length": 0, "longest_tweet_length": 0, "shortest_tweet_length": 0,
+            # Media usage metrics
+            "tweets_with_media_count": 0, "media_usage_percentage": 0,
+            "avg_likes_with_media": 0, "avg_likes_without_media": 0,
+            # Hashtag and mention metrics
+            "total_hashtags_used": 0, "avg_hashtags_per_tweet": 0, "tweets_with_hashtags_percentage": 0,
+            "total_mentions_used": 0, "avg_mentions_per_tweet": 0,
+            # Activity patterns
+            "most_active_hour": 0, "most_active_day": "Unknown", "top_activity_hours": [],
+            # Performance metrics
+            "highest_likes": 0, "top_tweet_text": "", "top_tweet_url": "",
+            "viral_tweets_count": 0, "viral_content_percentage": 0,
+            # Engagement ratios
+            "like_to_view_ratio": 0, "retweet_to_like_ratio": 0, "reply_to_like_ratio": 0,
+            "engagement_score": 0, "total_engagement": 0,
+        }
+    
     def _is_mock_tweet(self, item: Dict) -> bool:
         """Detect if a tweet is mock/invalid data that should be ignored."""
         # Check for missing essential fields that real tweets should have
@@ -329,12 +530,19 @@ class TweetDataProcessor:
         return False
     
     def _process_single_tweet(self, item: Dict, hashtags_counter: Counter, 
-                             mentions_counter: Counter, all_author_data: List) -> Optional[Dict]:
+                             mentions_counter: Counter, all_author_data: List, target_username: str = None) -> Optional[Dict]:
         """Process a single tweet item."""
         # Extract author data
         author = item.get("author", {})
         if author:
-            all_author_data.append(author)
+            # Only collect author data from the target user if target_username is specified
+            # This prevents random accounts from being saved in replies data
+            if target_username:
+                author_username = author.get("userName", "").lower()
+                if author_username == target_username.lower():
+                    all_author_data.append(author)
+            else:
+                all_author_data.append(author)
         
         # Check if this is a mock/invalid tweet (has minimal or no real data)
         is_mock_tweet = self._is_mock_tweet(item)
@@ -385,9 +593,21 @@ class TweetDataProcessor:
             "Mentions": ", ".join(mentions),
         }
     
-    def _extract_best_account_details(self, all_author_data: List[Dict]) -> Dict:
+    def _extract_best_account_details(self, all_author_data: List[Dict], target_username: str = None) -> Dict:
         """Extract the most complete account details from author data."""
         if not all_author_data:
+            # If no author data and we have a target username, create a basic structure
+            if target_username:
+                return {
+                    "name": target_username,
+                    "username": target_username,
+                    "bio": "",
+                    "followers_count": 0,
+                    "following_count": 0,
+                    "tweet_count": 0,
+                    "verified": False,
+                    "profile_image_url": ""
+                }
             return {}
         
         # Find the author data with the most complete information
@@ -422,11 +642,28 @@ class TweetDataProcessor:
         score = 0
         
         # Check for follower metrics (high priority)
-        if author.get("followers", 0) > 0 or author.get("followersCount", 0) > 0:
+        followers = (author.get("followers") or author.get("followersCount") or 
+                    author.get("followers_count") or 
+                    author.get("publicMetrics", {}).get("followers_count") or
+                    safe_get_nested(author, ["publicMetrics", "followers_count"]) or
+                    safe_get_nested(author, ["public_metrics", "followers_count"]) or 0)
+        if followers > 0:
             score += 3
-        if author.get("following", 0) > 0 or author.get("followingCount", 0) > 0:
+            
+        following = (author.get("following") or author.get("followingCount") or 
+                    author.get("following_count") or author.get("friends_count") or
+                    author.get("publicMetrics", {}).get("following_count") or
+                    safe_get_nested(author, ["publicMetrics", "following_count"]) or
+                    safe_get_nested(author, ["public_metrics", "following_count"]) or 0)
+        if following > 0:
             score += 2
-        if author.get("statusesCount", 0) > 0:
+            
+        tweet_count = (author.get("statusesCount") or author.get("statuses_count") or
+                      author.get("tweet_count") or
+                      author.get("publicMetrics", {}).get("tweet_count") or
+                      safe_get_nested(author, ["publicMetrics", "tweet_count"]) or
+                      safe_get_nested(author, ["public_metrics", "tweet_count"]) or 0)
+        if tweet_count > 0:
             score += 2
         
         # Check for profile information (lower priority)
@@ -437,14 +674,42 @@ class TweetDataProcessor:
         
         return score
     
+    def _convert_to_ist_format(self, twitter_date_str: str) -> str:
+        """Convert Twitter date string to IST format."""
+        if not twitter_date_str or twitter_date_str == "":
+            return ""
+        
+        try:
+            # Parse the Twitter date format: "Mon Jul 08 09:31:59 +0000 2013"
+            utc_dt = datetime.strptime(twitter_date_str, TWITTER_DATE_FORMAT)
+            
+            # Convert to IST
+            ist_tz = pytz.timezone(IST_TIMEZONE)
+            ist_dt = utc_dt.astimezone(ist_tz)
+            
+            # Format as a more readable IST date
+            # Format: "8 July 2013, 3:01 PM IST"
+            formatted_date = ist_dt.strftime("%d %B %Y, %I:%M %p IST")
+            
+            return formatted_date
+        except ValueError:
+            # If parsing fails, return the original string
+            return twitter_date_str
+    
     def _standardize_account_details(self, author_data: Dict) -> Dict:
         """Standardize account details from various possible field names."""
-        # Try multiple possible field names for metrics
+        # Debug: Print raw author data keys (only in debug mode)
+        if st.session_state.get('debug_mode', False):
+            st.write(f"Debug - Author data keys: {list(author_data.keys())}")
+        
+        # Try multiple possible field names for metrics with additional variations
         followers_count = (
             author_data.get("followers") or
             author_data.get("followersCount") or
             author_data.get("followers_count") or
+            author_data.get("publicMetrics", {}).get("followers_count") or
             safe_get_nested(author_data, ["publicMetrics", "followers_count"]) or
+            safe_get_nested(author_data, ["public_metrics", "followers_count"]) or
             0
         )
         
@@ -453,7 +718,9 @@ class TweetDataProcessor:
             author_data.get("followingCount") or
             author_data.get("following_count") or
             author_data.get("friends_count") or
+            author_data.get("publicMetrics", {}).get("following_count") or
             safe_get_nested(author_data, ["publicMetrics", "following_count"]) or
+            safe_get_nested(author_data, ["public_metrics", "following_count"]) or
             0
         )
         
@@ -461,10 +728,23 @@ class TweetDataProcessor:
             author_data.get("statusesCount") or
             author_data.get("statuses_count") or
             author_data.get("tweet_count") or
+            author_data.get("publicMetrics", {}).get("tweet_count") or
             safe_get_nested(author_data, ["publicMetrics", "tweet_count"]) or
+            safe_get_nested(author_data, ["public_metrics", "tweet_count"]) or
             0
         )
         
+        # Extract account creation date
+        raw_create_date = (
+            author_data.get("createdAt") or
+            author_data.get("created_at") or
+            author_data.get("account_create_date") or
+            ""
+        )
+        
+        # Convert to IST format if we have a valid date
+        account_create_date = self._convert_to_ist_format(raw_create_date)
+        
         return {
             "name": author_data.get("name", ""),
             "username": author_data.get("userName", "") or author_data.get("username", ""),
@@ -474,6 +754,12 @@ class TweetDataProcessor:
             "tweet_count": tweet_count,
             "verified": author_data.get("verified", False) or author_data.get("isVerified", False),
             "profile_image_url": author_data.get("profileImageUrl", "") or author_data.get("profile_image_url", ""),
+            "account_create_date": account_create_date,
+            # Engagement metrics will be calculated from tweet data and added later
+            "likes_count": 0,
+            "views_count": 0,
+            "reply_count": 0,
+            "repost_count": 0,
         }
 
 # =============================================================================
@@ -510,6 +796,12 @@ class UIComponents:
     @staticmethod
     def _display_account_metrics(account_details: Dict) -> None:
         """Display account metrics (followers, following, posts)."""
+        # Account creation date
+        create_date = account_details.get('account_create_date', '')
+        if create_date:
+            st.caption(f"📅 Account created: {create_date}")
+        
+        # Basic metrics
         m1, m2, m3 = st.columns(3)
         
         followers = account_details.get('followers_count', 0)
@@ -532,10 +824,225 @@ class UIComponents:
             help="Total tweet count from Twitter API"
         )
         
+        # Engagement metrics
+        likes = account_details.get('likes_count', 0)
+        views = account_details.get('views_count', 0)
+        replies = account_details.get('reply_count', 0)
+        reposts = account_details.get('repost_count', 0)
+        
+        if likes > 0 or views > 0 or replies > 0 or reposts > 0:
+            st.caption("**📊 Total Engagement:**")
+            e1, e2, e3, e4 = st.columns(4)
+            
+            e1.metric(
+                "Likes",
+                format_large_number(likes),
+                help="Total likes count"
+            )
+            e2.metric(
+                "Views",
+                format_large_number(views),
+                help="Total views/impressions count"
+            )
+            e3.metric(
+                "Replies",
+                format_large_number(replies),
+                help="Total replies count"
+            )
+            e4.metric(
+                "Reposts",
+                format_large_number(reposts),
+                help="Total reposts/retweets count"
+            )
+            
+            # Advanced metrics sections
+            UIComponents._display_content_quality_metrics(account_details)
+            UIComponents._display_media_usage_metrics(account_details)
+            UIComponents._display_activity_patterns(account_details)
+            UIComponents._display_performance_metrics(account_details)
+            UIComponents._display_engagement_ratios(account_details)
+        
         # Warning for missing data
         if followers == 0 and following == 0 and posts == 0:
             st.warning("⚠️ Account metrics unavailable - this may be due to API limitations or account privacy settings")
     
+    @staticmethod
+    def _display_content_quality_metrics(account_details: Dict) -> None:
+        """Display content quality metrics."""
+        avg_likes = account_details.get('avg_likes_per_tweet', 0)
+        avg_views = account_details.get('avg_views_per_tweet', 0)
+        engagement_rate = account_details.get('avg_engagement_rate', 0)
+        avg_length = account_details.get('avg_tweet_length', 0)
+        
+        if avg_likes > 0 or avg_views > 0 or engagement_rate > 0:
+            st.caption("**📈 Content Quality:**")
+            q1, q2, q3, q4 = st.columns(4)
+            
+            q1.metric(
+                "Avg Likes/Tweet",
+                f"{avg_likes:.1f}",
+                help="Average likes per tweet"
+            )
+            q2.metric(
+                "Avg Views/Tweet",
+                format_large_number(int(avg_views)),
+                help="Average views per tweet"
+            )
+            q3.metric(
+                "Engagement Rate",
+                f"{engagement_rate:.1f}%",
+                help="(Likes + Retweets) / Views * 100"
+            )
+            q4.metric(
+                "Avg Tweet Length",
+                f"{avg_length:.0f} chars",
+                help="Average character length per tweet"
+            )
+    
+    @staticmethod
+    def _display_media_usage_metrics(account_details: Dict) -> None:
+        """Display media usage metrics."""
+        media_count = account_details.get('tweets_with_media_count', 0)
+        media_percentage = account_details.get('media_usage_percentage', 0)
+        likes_with_media = account_details.get('avg_likes_with_media', 0)
+        likes_without_media = account_details.get('avg_likes_without_media', 0)
+        
+        if media_count > 0 or media_percentage > 0:
+            st.caption("**🎬 Media Usage:**")
+            m1, m2, m3, m4 = st.columns(4)
+            
+            m1.metric(
+                "Tweets with Media",
+                f"{media_count}",
+                help="Number of tweets with media attachments"
+            )
+            m2.metric(
+                "Media Usage",
+                f"{media_percentage:.1f}%",
+                help="Percentage of tweets with media"
+            )
+            m3.metric(
+                "Avg Likes (Media)",
+                f"{likes_with_media:.1f}",
+                help="Average likes for tweets with media"
+            )
+            m4.metric(
+                "Avg Likes (No Media)",
+                f"{likes_without_media:.1f}",
+                help="Average likes for tweets without media"
+            )
+    
+    @staticmethod
+    def _display_activity_patterns(account_details: Dict) -> None:
+        """Display activity pattern metrics."""
+        most_active_hour = account_details.get('most_active_hour', 0)
+        most_active_day = account_details.get('most_active_day', 'Unknown')
+        top_hours = account_details.get('top_activity_hours', [])
+        
+        if most_active_hour > 0 or most_active_day != 'Unknown':
+            st.caption("**⏰ Activity Patterns:**")
+            a1, a2, a3, a4 = st.columns(4)
+            
+            a1.metric(
+                "Most Active Hour",
+                f"{most_active_hour}:00",
+                help="Hour of day with most tweets"
+            )
+            a2.metric(
+                "Most Active Day",
+                most_active_day,
+                help="Day of week with most tweets"
+            )
+            a3.metric(
+                "Top Hours",
+                ", ".join([f"{h}:00" for h in top_hours[:2]]),
+                help="Top active hours"
+            )
+            
+            # Hashtag and mention usage
+            hashtags = account_details.get('total_hashtags_used', 0)
+            mentions = account_details.get('total_mentions_used', 0)
+            a4.metric(
+                "Hashtags Used",
+                f"{hashtags}",
+                help="Total hashtags used in tweets"
+            )
+    
+    @staticmethod
+    def _display_performance_metrics(account_details: Dict) -> None:
+        """Display performance metrics."""
+        highest_likes = account_details.get('highest_likes', 0)
+        viral_count = account_details.get('viral_tweets_count', 0)
+        viral_percentage = account_details.get('viral_content_percentage', 0)
+        top_tweet_text = account_details.get('top_tweet_text', '')
+        top_tweet_url = account_details.get('top_tweet_url', '')
+        
+        if highest_likes > 0 or viral_count > 0:
+            st.caption("**🚀 Performance:**")
+            p1, p2, p3, p4 = st.columns(4)
+            
+            p1.metric(
+                "Highest Likes",
+                format_large_number(highest_likes),
+                help="Most likes on a single tweet"
+            )
+            p2.metric(
+                "Viral Tweets",
+                f"{viral_count}",
+                help="Tweets in top 10% by likes"
+            )
+            p3.metric(
+                "Viral Content %",
+                f"{viral_percentage:.1f}%",
+                help="Percentage of viral tweets"
+            )
+            p4.metric(
+                "Engagement Score",
+                f"{account_details.get('engagement_score', 0):.1f}",
+                help="Weighted engagement score (likes×1 + retweets×2 + replies×3)"
+            )
+            
+            # Show top tweet if available
+            if top_tweet_text and top_tweet_url:
+                st.caption("**🏆 Top Performing Tweet:**")
+                with st.expander("View top tweet"):
+                    st.write(f"**Likes:** {format_large_number(highest_likes)}")
+                    st.write(f"**Text:** {top_tweet_text}")
+                    st.write(f"**URL:** {top_tweet_url}")
+    
+    @staticmethod
+    def _display_engagement_ratios(account_details: Dict) -> None:
+        """Display engagement ratio metrics."""
+        like_to_view = account_details.get('like_to_view_ratio', 0)
+        retweet_to_like = account_details.get('retweet_to_like_ratio', 0)
+        reply_to_like = account_details.get('reply_to_like_ratio', 0)
+        total_engagement = account_details.get('total_engagement', 0)
+        
+        if like_to_view > 0 or retweet_to_like > 0 or reply_to_like > 0:
+            st.caption("**📊 Engagement Ratios:**")
+            r1, r2, r3, r4 = st.columns(4)
+            
+            r1.metric(
+                "Like Rate",
+                f"{like_to_view:.2f}%",
+                help="Likes per view percentage"
+            )
+            r2.metric(
+                "Retweet Rate",
+                f"{retweet_to_like:.2f}%",
+                help="Retweets per like percentage"
+            )
+            r3.metric(
+                "Reply Rate",
+                f"{reply_to_like:.2f}%",
+                help="Replies per like percentage"
+            )
+            r4.metric(
+                "Total Engagement",
+                format_large_number(total_engagement),
+                help="Total likes + retweets + replies"
+            )
+    
     @staticmethod
     def display_key_metrics(df: pd.DataFrame) -> None:
         """Display key engagement metrics."""
@@ -896,7 +1403,7 @@ class TwitterAnalyzerApp:
                 return
             
             # Process data
-            df, metrics = self.processor.process_tweets(raw_data)
+            df, metrics = self.processor.process_tweets(raw_data, self.username)
             
             # Generate AI summary if available
             gemini_summary = None