import pandas as pd
import numpy as np
import warnings
warnings.filterwarnings('ignore')

# Load a public synthetic social media content dataset
np.random.seed(42)
n_posts = 500
views = np.random.randint(100, 100000, n_posts)
df = pd.DataFrame({
    'post_id': range(1, n_posts+1),
    'platform': np.random.choice(['YouTube','Instagram','TikTok'], n_posts),
    'date': pd.date_range('2023-01-01', periods=n_posts, freq='6h'),
    'views': views,
    'likes': (views * np.random.uniform(0.02, 0.15, n_posts)).astype(int),
    'comments': (views * np.random.uniform(0.001, 0.05, n_posts)).astype(int),
    'shares': (views * np.random.uniform(0.001, 0.03, n_posts)).astype(int)
})
print(df.shape)
print(df.head(3))

def calculate_engagement_rate(row):
    return (row['likes'] / row['views'] * 100) if row['views'] > 0 else np.nan

df['engagement_rate'] = df.apply(calculate_engagement_rate, axis=1)
print(df[['post_id', 'platform', 'views', 'likes', 'engagement_rate']].head(3))

high_engagement = df[df['engagement_rate'] > 10]['post_id'].tolist()
print(f'Number of posts with >10% engagement: {len(high_engagement)}')
print('Sample top post IDs:', high_engagement[:5])

platform_counts = {}
for platform in df['platform'].unique():
    count = df[df['platform'] == platform].shape[0]
    platform_counts[platform] = count
print('Number of posts per platform:', platform_counts)

def get_top_posts(df, n=5):
    top = df.sort_values('engagement_rate', ascending=False).head(n)
    return [{'post_id': row['post_id'], 'platform': row['platform'], 'engagement_rate': row['engagement_rate']} for _, row in top.iterrows()]

top_5 = get_top_posts(df, 5)
print('Top 5 posts by engagement rate:')
for post in top_5:
    print(post)

platform_means = df.groupby('platform')['engagement_rate'].mean().to_dict()
for platform, mean_eng in platform_means.items():
    print(f'Average engagement rate on {platform}: {mean_eng:.2f}%')

percentiles = [0.25, 0.5, 0.75]
summary = {}
for platform in df['platform'].unique():
    rates = df[df['platform'] == platform]['engagement_rate']
    summary[platform] = {p: np.percentile(rates, p*100) for p in percentiles}
print('Engagement rate percentiles by platform:')
for plat, pctiles in summary.items():
    print(plat, {f'{int(p*100)}th': round(val,2) for p, val in pctiles.items()})

def find_viral_posts(df):
    viral_list = []
    platforms = df['platform'].unique()
    for plat in platforms:
        threshold = np.percentile(df[df['platform'] == plat]['engagement_rate'], 90)
        viral = df[(df['platform'] == plat) & (df['engagement_rate'] > threshold)]
        viral_list.extend(viral['post_id'].tolist())
    return viral_list

viral_post_ids = find_viral_posts(df)
print(f'Viral post IDs (above 90th percentile for each platform): {viral_post_ids[:8]}...')

def platform_summary(df):
    reports = []
    for plat in df['platform'].unique():
        subset = df[df['platform'] == plat]
        entry = {
            'platform': plat,
            'n_posts': subset.shape[0],
            'avg_engagement_rate': round(subset['engagement_rate'].mean(),2),
            'top_post_id': subset.sort_values('engagement_rate', ascending=False).iloc[0]['post_id']
        }
        reports.append(entry)
    return reports

report = platform_summary(df)
for item in report:
    print(item)

# Simulate some missing like counts
df_missing = df.copy()
df_missing.loc[np.random.choice(df_missing.index, 10, replace=False), 'likes'] = np.nan

def safe_engagement(row):
    if pd.isna(row['likes']) or row['views'] == 0:
        return np.nan
    return row['likes'] / row['views'] * 100

df_missing['safe_engagement_rate'] = df_missing.apply(safe_engagement, axis=1)
print(df_missing[['likes', 'views', 'safe_engagement_rate']].head(10))

# Mistake: calculate mean engagement rate on ALL posts regardless of platform
mean_all = df['engagement_rate'].mean()
print(f'Average engagement rate across all platforms: {mean_all:.2f}%')

# Fix: calculate mean for each platform with a function
def group_mean_engagement(df):
    return df.groupby('platform')['engagement_rate'].mean().to_dict()

platform_means = group_mean_engagement(df)
print('Proper per-platform means:', platform_means)

def suspicious_high_engagement(row):
    return row['engagement_rate'] > 30 and row['views'] < 200

suspicious = df[df.apply(suspicious_high_engagement, axis=1)]
print(f'Number of suspiciously high engagement rate posts: {len(suspicious)}')
print(suspicious[['post_id', 'views', 'likes', 'engagement_rate']].head())

# Example: Consistently defining engagement rate as likes divided by views times 100
def consistent_engagement(df, like_col='likes', view_col='views'):
    return (df[like_col] / df[view_col] * 100).round(2)

df['engagement_rate2'] = consistent_engagement(df)
print(df[['likes', 'views', 'engagement_rate2']].head(3))

# Step 1: Engagement rates are already calculated in 'engagement_rate'
# Step 2: Identify top 5 posts overall
top5_end_to_end = df.sort_values('engagement_rate', ascending=False).head(5)
print('Top 5 posts by engagement rate:')
print(top5_end_to_end[['post_id','platform','engagement_rate','likes','views']])

# Step 3: Suggest the platform with the highest average engagement
avg_engagements = df.groupby('platform')['engagement_rate'].mean()
best_platform = avg_engagements.idxmax()
print(f'Best platform for posting, based on average engagement rate: {best_platform}')

# YouTube CTA: Find more tutorials at YouTube.com!
print('Subscribe for more analytics walkthroughs on our channel!')