import pandas as pd
import numpy as np
import os, pickle
from pathlib import Path
import time
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')

# Load a time series dataset representing daily social media engagement
np.random.seed(42)
n_days = 365
dates = pd.date_range('2023-01-01', periods=n_days, freq='D')
views = np.random.randint(1000, 50000, n_days)
likes = (views * np.random.uniform(0.03, 0.12, n_days)).astype(int)
df = pd.DataFrame({
    'date': dates,
    'views': views,
    'likes': likes,
    'engagement_rate': np.round(likes / views * 100, 2)
})
print(df.head(3))

# Schedule: simulate updating the dataset every day
def fetch_new_data(last_date):
    new_date = last_date + timedelta(days=1)
    views = np.random.randint(1000, 50000)
    likes = int(views * np.random.uniform(0.03, 0.12))
    engagement_rate = round(likes / views * 100, 2)
    return {'date': new_date, 'views': views, 'likes': likes, 'engagement_rate': engagement_rate}

next_record = fetch_new_data(df['date'].iloc[-1])
print(next_record)

# Example: Append new data daily in a loop to simulate automatic updates
update_days = 7
for _ in range(update_days):
    record = fetch_new_data(df['date'].iloc[-1])
    df = pd.concat([df, pd.DataFrame([record])], ignore_index=True)
print(df.tail(8))

latest = df.iloc[-1]
print(f"Date: {latest['date'].strftime('%Y-%m-%d')}")
print(f"Engagement Rate: {latest['engagement_rate']}%")

last_month = df[df['date'] > df['date'].max() - pd.DateOffset(days=30)]
top_day = last_month.sort_values('engagement_rate', ascending=False).iloc[0]
print(f"Top day: {top_day['date'].strftime('%Y-%m-%d')}, Engagement Rate: {top_day['engagement_rate']}%")

df.to_csv('updated_engagement.csv', index=False)
print('Updated analytics data saved to updated_engagement.csv')

def auto_update_simulate(n_updates, sleep_seconds=1):
    for i in range(n_updates):
        record = fetch_new_data(df['date'].iloc[-1])
        print(f"[{datetime.now().strftime('%H:%M:%S')}] New data: {record}")
        globals()['df'] = pd.concat([df, pd.DataFrame([record])], ignore_index=True)
        time.sleep(sleep_seconds)
auto_update_simulate(3, sleep_seconds=0.2)

def update_if_needed():
    today = pd.Timestamp.today().normalize()
    last_recorded_date = df['date'].iloc[-1].normalize()
    if last_recorded_date < today:
        new = fetch_new_data(last_recorded_date)
        globals()['df'] = pd.concat([df, pd.DataFrame([new])], ignore_index=True)
        print(f"Update added for {new['date']}")
    else:
        print('Data is already up-to-date for today.')
update_if_needed()

def log_update():
    with open('update_log.txt', 'a') as f:
        ts = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        f.write(f'Update at {ts}\n')
log_update()
print('Update time logged in update_log.txt')

# Load a synthetic post-level dataset
n_posts = 15
posts = pd.DataFrame({
    'post_id': range(1, n_posts+1),
    'platform': np.random.choice(['YouTube', 'Instagram', 'TikTok'], n_posts),
    'date': pd.date_range('2023-02-01', periods=n_posts, freq='D'),
    'views': np.random.randint(500, 10000, n_posts),
    'likes': np.random.randint(50, 1000, n_posts)
})
merged = posts.merge(df, on='date', suffixes=('_post', '_day'))
print(merged[['post_id', 'platform', 'date', 'views_post', 'likes_post', 'views_day', 'likes_day']].head())

hours = pd.date_range('2023-06-01', periods=24, freq='H')
hourly = pd.DataFrame({
    'datetime': hours,
    'views': np.random.randint(100, 2000, 24),
    'likes': np.random.randint(5, 300, 24)
})
hourly['engagement_rate'] = np.round(hourly['likes'] / hourly['views'] * 100, 2)
print(hourly.head())

# Remove random days and forward-fill missing values
dropped = df.copy()
np.random.seed(42)
missing_idx = np.random.choice(dropped.index, size=4, replace=False)
dropped = dropped.drop(missing_idx).reset_index(drop=True)
dropped = dropped.set_index('date').asfreq('D')
filled = dropped.fillna(method='ffill')
print(filled.head(8))

# Add a deliberate duplicate and fix it
dup_df = pd.concat([df, df.iloc[[-1]]], ignore_index=True)
print('Duplicates before deduplication:', dup_df['date'].duplicated().sum())
deduped_df = dup_df.drop_duplicates(subset=['date'], keep='first')
print('Duplicates after deduplication:', deduped_df['date'].duplicated().sum())

weekday_rates = df.copy()
weekday_rates['weekday'] = weekday_rates['date'].dt.day_name()
mean_rates = weekday_rates.groupby('weekday')['engagement_rate'].mean().sort_values(ascending=False)
print(mean_rates)

report_file = 'engagement_report.txt'
with open(report_file, 'w') as f:
    f.write(f"Engagement Data Report\n")
    f.write(f"Last updated: {df['date'].max().strftime('%Y-%m-%d')}\n\n")
    f.write(f"Latest Day: {df.iloc[-1].to_dict()}\n")
    f.write(f"Average Engagement (Last 7 days): {df.tail(7)['engagement_rate'].mean():.2f}%\n")
print(f'Report saved as {report_file}')

class DataScheduler:
    def __init__(self, df):
        self.df = df
    def update(self):
        today = pd.Timestamp.today().normalize()
        last = self.df['date'].iloc[-1].normalize()
        if last < today:
            rec = fetch_new_data(last)
            self.df = pd.concat([self.df, pd.DataFrame([rec])], ignore_index=True)
            print(f"New data for {rec['date'].strftime('%Y-%m-%d')} added.")
        else:
            print('Already up to date!')
    def save(self, file):
        self.df.to_csv(file, index=False)
        print(f"Saved updates to {file}")

scheduler = DataScheduler(df)
scheduler.update()
scheduler.save('scheduled_update.csv')

df['week'] = df['date'].dt.isocalendar().week
weekly = df.groupby('week')['engagement_rate'].mean().sort_values(ascending=False)
top3 = weekly.head(3)
print('Top 3 weeks for engagement:', top3.index.tolist())
print('Suggested post schedule: Publish major content in these weeks next year.')
reco = 'Recommendation: Boost ad spend or schedule influencer collaborations in those periods to maximize your audience reach.'
print(reco)