# Always start by hiding unwanted warning messages for a clear experience
import warnings
import numpy as np
np.random.seed(42)
from statsmodels.tools.sm_exceptions import ConvergenceWarning, ValueWarning
warnings.filterwarnings("ignore", category=ValueWarning)
warnings.filterwarnings("ignore", category=ConvergenceWarning)
warnings.filterwarnings("ignore", category=RuntimeWarning)
warnings.filterwarnings("ignore")

# Data setup: Load the classic Airline Passengers dataset
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/airline-passengers.csv"
df = pd.read_csv(url, parse_dates=["Month"], index_col="Month")
print("Shape:", df.shape)
df.head()

# Plot the time series for a first visual inspection
df.plot(figsize=(10,4), legend=False, title="Monthly Airline Passengers")
plt.ylabel("Number of passengers")
plt.show()

# Check for stationarity using a rolling mean and variance
window = 12  # 12 months = 1 year
rolling_mean = df["Passengers"].rolling(window=window).mean()
rolling_std = df["Passengers"].rolling(window=window).std()

plt.figure(figsize=(10,4))
plt.plot(df["Passengers"], label="Original")
plt.plot(rolling_mean, label="Rolling Mean (1 year)")
plt.plot(rolling_std, label="Rolling Std Dev (1 year)")
plt.legend()
plt.title("Stationarity: Rolling Statistics")
plt.show()

# The Augmented Dickey-Fuller Test: a formal test for stationarity
from statsmodels.tsa.stattools import adfuller
result = adfuller(df["Passengers"])
print("ADF Statistic:", result[0])
print("p-value:", result[1])

# Apply first-order differencing to remove trend
diff = df["Passengers"].diff().dropna()
plt.figure(figsize=(10,4))
plt.plot(diff, label="First-differenced series")
plt.legend()
plt.title("After First Differencing")
plt.show()

# Re-run the ADF test on the differenced series
result_diff = adfuller(diff)
print("ADF Statistic after differencing:", result_diff[0])
print("p-value after differencing:", result_diff[1])

# Plot ACF and PACF for the differenced series
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
fig, axes = plt.subplots(1,2, figsize=(12,4))
plot_acf(diff, ax=axes[0], lags=24, title="ACF - Airline Passengers")
plot_pacf(diff, ax=axes[1], lags=24, title="PACF - Airline Passengers")
plt.tight_layout()
plt.show()

# Fit ARIMA (p=1, d=1, q=1) to the data and visualize prediction
from statsmodels.tsa.arima.model import ARIMA
import warnings
from statsmodels.tools.sm_exceptions import ConvergenceWarning, ValueWarning
warnings.filterwarnings("ignore", category=ValueWarning)
warnings.filterwarnings("ignore", category=ConvergenceWarning)
warnings.filterwarnings("ignore", category=RuntimeWarning)

# Ensure the index has proper frequency for ARIMA
df_arima = df.copy()
df_arima.index.freq = "MS"

try:
    model = ARIMA(df_arima["Passengers"], order=(1, 1, 1))
    model_fit = model.fit()
    print(model_fit.summary())

    forecast = model_fit.predict(start=len(df_arima)-12, end=len(df_arima)-1, typ="levels")
    df_arima["Passengers"].iloc[-24:].plot(label="Actual", marker="o")
    forecast.plot(label="Forecast", marker="x")
    plt.title("ARIMA Forecast vs Last 24 Months")
    plt.legend()
    plt.show()
except Exception as e:
    print("An error occurred during ARIMA fitting or forecasting:", e)
    

# Handling missing data in time series
df_missing = df.copy()
df_missing.iloc[10:15] = None  # Simulate missing values
print(df_missing.isnull().sum())

# Fill using forward-fill (propagate last value)
df_missing_ffill = df_missing.fillna(method="ffill")
df_missing_ffill.head(20)

# Practice: Identify if a new series needs differencing
import numpy as np
np.random.seed(42)
random_walk = np.cumsum(np.random.randn(100))
plt.plot(random_walk)
plt.title("Random Walk Example")
plt.show()

# Check ADF test for stationarity of the random walk
from statsmodels.tsa.stattools import adfuller
rw_result = adfuller(random_walk)
print("Random walk p-value:", rw_result[1])

# Quick You: Choose which transformation makes data stationary
choice = input("If a series drifts upward over time, what is your first stationarizing step? (a) take log, (b) difference, (c) z-score: ")
if choice.lower().startswith("b"):
    print("Correct! Differencing is the main way to remove trends.")
else:
    print("Nice try! Differencing is usually first. Logs help with spread, z-scores scale the series.")
    

# Challenge: Try ARIMA on your own synthetic data
synthetic = np.sin(np.linspace(0, 20 * np.pi, 120)) + np.random.normal(scale=0.5, size=120)
plt.plot(synthetic)
plt.title("Synthetic Time Series")
plt.show()

from statsmodels.tsa.arima.model import ARIMA
model2 = ARIMA(synthetic, order=(1,0,0))
fit2 = model2.fit()
pred = fit2.predict(start=100, end=119)
plt.plot(synthetic, label="Actual")
plt.plot(range(100,120), pred, label="ARIMA Forecast", linestyle='--')
plt.legend()
plt.title("Forecast: ARIMA on Synthetic Series")
plt.show()

# Mini-project (Part 1): Simulate a real-world process
np.random.seed(0)
visits_base = 100 + np.arange(60) * 2  # upward trend
visits_season = 10 * np.sin(np.linspace(0, 6*np.pi, 60))
noise = np.random.normal(0, 3, size=60)
website_visits = visits_base + visits_season + noise
plt.plot(website_visits)
plt.title("Simulated Monthly Website Visits")
plt.show()

# Mini-project (Part 2): Analyze stationarity for simulated visits
plt.figure(figsize=(10,4))
plt.plot(website_visits, label="Original")
plt.plot(pd.Series(website_visits).rolling(12).mean(), label="Mean")
plt.plot(pd.Series(website_visits).rolling(12).std(), label="Std Dev")
plt.legend()
plt.title("Rolling Stats of Simulated Visits")
plt.show()

result = adfuller(website_visits)
print("ADF Statistic:", result[0], "p-value:", result[1])