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

# Let us load the YouTube Trending Videos dataset
try:
    from pathlib import Path
    import os, pickle
    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)
    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))

# Let us introduce missing values for demonstration
df_missing = df.copy()
np.random.seed(42)
missing_idx = np.random.choice(df_missing.index, size=30, replace=False)
df_missing.loc[missing_idx, 'likes'] = np.nan
df_missing.loc[missing_idx[:15], 'views'] = np.nan
print(df_missing.head(10))

# Basic: Count missing values per column
print(df_missing.isnull().sum())

# Basic: List rows with missing likes or views
print(df_missing[df_missing['likes'].isnull() | df_missing['views'].isnull()].head())

# Fill missing likes with the median, views with the mean
df_filled = df_missing.copy()
likes_median = df_filled['likes'].median()
views_mean = df_filled['views'].mean()
df_filled['likes'].fillna(likes_median, inplace=True)
df_filled['views'].fillna(views_mean, inplace=True)
print('Missing after fill:', df_filled.isnull().sum())

import matplotlib.pyplot as plt
missing = df_missing.isnull().sum()
missing = missing[missing > 0]
plt.figure(figsize=(6,3))
missing.plot(kind='bar', color='tomato')
plt.title('Missing Value Count by Column')
plt.ylabel('Count')
plt.tight_layout()
plt.savefig('missing_pattern.png')
plt.close()