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

# Set up the dataset: YouTube Trending Videos
import os, pickle
from pathlib import Path
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request

SCOPES = ['https://www.googleapis.com/auth/youtube.readonly']

def get_yt_service():
    api_key = os.environ.get('YOUTUBE_API_KEY')
    if api_key:
        return build('youtube', 'v3', developerKey=api_key)
    if Path('client_secret.json').exists():
        creds = None
        if Path('token_ro.pickle').exists():
            with open('token_ro.pickle', 'rb') as f:
                creds = pickle.load(f)
        if not creds or not creds.valid:
            if creds and creds.expired and creds.refresh_token:
                creds.refresh(Request())
            else:
                flow = InstalledAppFlow.from_client_secrets_file('client_secret.json', SCOPES)
                creds = flow.run_local_server(port=0)
            with open('token_ro.pickle', 'wb') as f:
                pickle.dump(creds, f)
        return build('youtube', 'v3', credentials=creds)
    raise EnvironmentError('Set YOUTUBE_API_KEY or provide client_secret.json')

def fetch_yt_trending(max_results=200, region='US'):
    youtube = get_yt_service()
    records, token = [], None
    while len(records) < max_results:
        resp = youtube.videos().list(
            part='snippet,statistics',
            chart='mostPopular',
            regionCode=region,
            maxResults=min(50, max_results - len(records)),
            pageToken=token
        ).execute()
        for item in resp.get('items', []):
            s = item['snippet']; st = item.get('statistics', {})
            records.append({
                'video_id':      item['id'],
                'trending_date': pd.Timestamp.today().date(),
                'title':         s.get('title', ''),
                'channel_title': s.get('channelTitle', ''),
                'category_id':   s.get('categoryId', ''),
                'views':         int(st.get('viewCount', 0)),
                'likes':         int(st.get('likeCount', 0)),
                'comment_count': int(st.get('commentCount', 0)),
            })
        token = resp.get('nextPageToken')
        if not token: break
    return pd.DataFrame(records)

try:
    df = fetch_yt_trending()
    print('Live trending data:', df.shape)
except Exception as e:
    print(f'Falling back to synthetic: {e}')
    np.random.seed(42)
    n = 1000
    df = pd.DataFrame({
        'video_id':      [f'vid{i}' for i in range(n)],
        'trending_date': pd.date_range('2023-01-01', periods=n, freq='D'),
        'title':         [f'Video Title {i}' for i in range(n)],
        'channel_title': np.random.choice(['ChannelA','ChannelB','ChannelC'], n),
        'category_id':   np.random.choice([1,2,10,22,24,28], n),
        'views':         np.random.randint(10000, 5000000, n),
        'likes':         np.random.randint(100, 200000, n),
        'comment_count': np.random.randint(10, 50000, n),
    })
    print('Synthetic fallback:', df.shape)

print(df.head(3))

recent_videos = df.sort_values('trending_date', ascending=False).head(5)
print('Top recent trending videos:')
print(recent_videos[['title','channel_title','category_id','views','likes','comment_count']])

df['engagement_rate'] = (df['likes'] + df['comment_count']) / df['views']
print('Engagement rate calculated for each video.')
print(df[['title','engagement_rate']].head(3))

top_views = df.sort_values('views', ascending=False).head(5)
print('Most watched trending videos:')
print(top_views[['title','channel_title','views','likes','engagement_rate']])

top_engagement = df.sort_values('engagement_rate', ascending=False).head(5)
print('Top videos by engagement rate:')
print(top_engagement[['title','channel_title','views','likes','comment_count','engagement_rate']])

category_summary = df.groupby('category_id').agg({'views':'mean','engagement_rate':'mean','video_id':'count'}).reset_index()
category_summary = category_summary.rename(columns={'video_id':'video_count'})
print(category_summary.sort_values('views', ascending=False))

one_week_ago = df['trending_date'].max() - pd.Timedelta(days=7)
recent_week = df[df['trending_date'] >= one_week_ago]
top_channels = recent_week['channel_title'].value_counts().head(5)
print('Channels with most trending videos in the past week:')
print(top_channels)

daily_views = df.groupby('trending_date')['views'].mean().reset_index()
import matplotlib.pyplot as plt
plt.figure(figsize=(10,4))
plt.plot(daily_views['trending_date'], daily_views['views'], marker='o', alpha=0.6)
plt.title('Average Trending Video Views per Day')
plt.xlabel('Date')
plt.ylabel('Avg Views')
plt.tight_layout()
plt.show()

top_views_thresh = df['views'].quantile(0.99)
top_engage_thresh = df['engagement_rate'].quantile(0.99)
viral_candidates = df[(df['views'] >= top_views_thresh) & (df['engagement_rate'] >= top_engage_thresh)]
print('Potential viral trending videos:')
print(viral_candidates[['title','channel_title','views','likes','engagement_rate']])

# Simulate missing values
df_missing = df.copy()
df_missing.loc[df_missing.sample(frac=0.02, random_state=42).index, 'likes'] = np.nan
df_missing['engagement_rate'] = (df_missing['likes'].fillna(0) + df_missing['comment_count'].fillna(0)) / df_missing['views']
print('Null-safe engagement rate (likes NaNs treated as zero):')
print(df_missing[['likes','comment_count','views','engagement_rate']].head(3))

# WRONG: averaging engagement with no grouping
wrong_avg = df['engagement_rate'].mean()
print(f'Overall avg engagement rate (misleading): {wrong_avg:.4f}')

# CORRECT: average engagement by category
correct_avg = df.groupby('category_id')['engagement_rate'].mean()
print('Avg engagement rate per category (correct): ')
print(correct_avg)

few_views = df.sort_values('views').head(5)
print('Smallest audience videos with engagement rates:')
print(few_views[['title','views','engagement_rate']])

channel_avg = df.groupby('channel_title')['views'].mean().sort_values(ascending=False).head(5)
print('Channels with top average trending views:')
print(channel_avg)

daily = df.groupby('trending_date').agg({'views':'mean','engagement_rate':'mean'}).reset_index()
daily['views_rolling7'] = daily['views'].rolling(7, min_periods=1).mean()
import matplotlib.pyplot as plt
plt.figure(figsize=(10,4))
plt.plot(daily['trending_date'], daily['views_rolling7'], label='7-Day Rolling Mean', color='orange')
plt.title('7-Day Rolling Average of Trending Video Views')
plt.xlabel('Date')
plt.ylabel('Rolling Avg Views')
plt.legend()
plt.tight_layout()
plt.show()

df['weekday'] = pd.to_datetime(df['trending_date']).dt.day_name()
weekday_engage = df.groupby('weekday')['engagement_rate'].mean().sort_values(ascending=False)
print('Average engagement rate by weekday:')
print(weekday_engage)

this_month = pd.to_datetime(df['trending_date']).dt.to_period('M').max().to_timestamp()
month_df = df[pd.to_datetime(df['trending_date']).dt.to_period('M') == this_month.to_period('M')]

# 1. Channel with most trending videos this month
top_channel = month_df['channel_title'].value_counts().index[0]
print(f'Top trending channel this month: {top_channel}')

# 2. Top three high-engagement videos from that channel
ch_videos = month_df[month_df['channel_title'] == top_channel]
top_ch_videos = ch_videos.sort_values('engagement_rate', ascending=False).head(3)
print('Most engaging video titles from that channel:')
print(top_ch_videos['title'])

# 3. Best weekday for engagement (use all their videos this month)
best_day = ch_videos.groupby('weekday')['engagement_rate'].mean().idxmax()
print(f'Recommended best day to post: {best_day}')

# Optional: Save a brief summary report
output_text = f"Best channel this month: {top_channel}\n" + \
              "Top engaging titles: " + ', '.join(top_ch_videos['title'].tolist()) + "\n" + \
              f"Best day to post: {best_day}\n"
with open('yt_trending_summary.txt', 'w') as f:
    f.write(output_text)
print('Wrote report to yt_trending_summary.txt')