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

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))

df['engagement_rate'] = (df['likes'] + df['comment_count']) / df['views']
print(df[['title', 'views', 'likes', 'comment_count', 'engagement_rate']].head())

top5_engaged = df.sort_values('engagement_rate', ascending=False).head(5)
print(top5_engaged[['title', 'views', 'likes', 'comment_count', 'engagement_rate']])

cat_group = df.groupby('category_id')['engagement_rate'].mean().sort_values(ascending=False)
print(cat_group)

top_commented = df.sort_values('comment_count', ascending=False).head(5)
print(top_commented[['title', 'views', 'likes', 'comment_count']])

import matplotlib.pyplot as plt
df_trend = df.groupby('trending_date')['views'].mean()
plt.figure(figsize=(10,4))
plt.plot(df_trend.index, df_trend.values, marker='o')
plt.title('Average Trending Video Views over Time')
plt.xlabel('Trending Date')
plt.ylabel('Average Views')
plt.tight_layout()
plt.show()

np.random.seed(42)
n_posts = 500
views = np.random.randint(100, 100000, n_posts)
df_posts = 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_posts.head(3))

df_posts['engagement_rate'] = (df_posts['likes'] + df_posts['comments'] + df_posts['shares']) / df_posts['views']
print(df_posts[['platform', 'views', 'likes', 'comments', 'shares', 'engagement_rate']].head())

eng_by_platform = df_posts.groupby('platform')['engagement_rate'].mean()
print(eng_by_platform)

post_time_group = df_posts.groupby(df_posts['date'].dt.hour)['views'].mean()
plt.figure(figsize=(8,4))
plt.bar(post_time_group.index, post_time_group.values)
plt.title('Average Views per Posting Hour')
plt.xlabel('Hour of Day')
plt.ylabel('Average Views')
plt.xticks(range(0,24))
plt.tight_layout()
plt.show()

n_videos = 300
views = np.random.randint(100, 500000, n_videos)
df_yt = pd.DataFrame({
    'video_id': range(1, n_videos+1),
    'publish_date': pd.date_range('2022-01-01', periods=n_videos, freq='D'),
    'views': views,
    'watch_time': np.random.randint(1000, 500000, n_videos),
    'likes': (views * np.random.uniform(0.01, 0.08, n_videos)).astype(int),
    'comments': (views * np.random.uniform(0.001, 0.02, n_videos)).astype(int),
    'ctr': np.round(np.random.uniform(2, 10, n_videos), 2)
})
print(df_yt.head(3))

df_yt['avg_watch_per_view'] = df_yt['watch_time'] / df_yt['views']
print(df_yt[['views', 'watch_time', 'avg_watch_per_view']].head())

top_ctr = df_yt.sort_values('ctr', ascending=False).head(5)
print(top_ctr[['video_id', 'views', 'ctr', 'likes', 'comments']])

# Flag potentially viral posts: high engagement & sharp view spikes
threshold = df_posts['engagement_rate'].quantile(0.95)
viral = df_posts[(df_posts['engagement_rate'] > threshold) & (df_posts['views'] > df_posts['views'].quantile(0.90))]
print(viral[['platform', 'views', 'engagement_rate']])

# Week-over-week growth for YouTube video views
yt_week = df_yt.set_index('publish_date')['views'].resample('W').sum()
yt_growth = yt_week.pct_change().fillna(0)
plt.figure(figsize=(8, 4))
plt.plot(yt_week.index, yt_growth.values, marker='o')
plt.title('Week-over-Week Growth in YouTube Video Views')
plt.xlabel('Week')
plt.ylabel('Growth Rate')
plt.axhline(0, color='red', linestyle='--')
plt.tight_layout()
plt.show()

# Simple machine learning: predict engagement rate based on views, likes, comments (linear regression)
from sklearn.linear_model import LinearRegression
X = df_posts[['views', 'likes', 'comments']]
y = df_posts['engagement_rate']
model = LinearRegression()
model.fit(X, y)
predicted = model.predict(X)
print('Sample actual vs predicted engagement rates:')
print(np.round(np.c_[y[:5], predicted[:5]], 4))

# Evaluate the prediction error using mean squared error
from sklearn.metrics import mean_squared_error
mse = mean_squared_error(y, predicted)
print(f'Mean Squared Error: {mse:.5f}')

# Simulate missing data: set some likes/comments/shares to np.nan
df_posts_missing = df_posts.copy()
mask = np.random.rand(len(df_posts_missing)) < 0.05
df_posts_missing.loc[mask, ['likes', 'comments', 'shares']] = np.nan
missing_summary = df_posts_missing[['likes', 'comments', 'shares']].isnull().sum()
print('Missing counts by column:')
print(missing_summary)

# Filling missing values before calculating engagement rate
df_filled = df_posts_missing.fillna(0)
df_filled['engagement_rate'] = (df_filled['likes'] + df_filled['comments'] + df_filled['shares']) / df_filled['views']
print('Engagement rates after filling missing values:')
print(df_filled['engagement_rate'].head())

# Incorrect CTR calculation example (wrong denominator!)
df_yt['ctr_wrong'] = df_yt['likes'] / df_yt['views']
print('First 3 wrong CTRs:', df_yt['ctr_wrong'].head(3).values)

# Correct CTR is already provided (percentage of impressions that resulted in a click)

# 1. Platform with highest average engagement
best_platform = eng_by_platform.idxmax()
best_rate = eng_by_platform.max()
# 2. On that platform, find the most engaging post (by engagement rate)
best_row = df_posts[df_posts['platform']==best_platform].sort_values('engagement_rate', ascending=False).iloc[0]
print(f'Best Platform: {best_platform}\nAverage Engagement Rate: {best_rate:.4f}')
print('Best Post Example:')
print(best_row[['date', 'views', 'likes', 'comments', 'shares', 'engagement_rate']])