import pandas as pd
import matplotlib.pyplot as plt

# Simulate a dataset for demonstration purposes
# In a real scenario, you would load your own CSV or other data source
data = {
    'Date': pd.to_datetime(pd.date_range(start='2020-01-01', periods=1000, freq='H')),
    'Value': [
        i * 0.1 +
        (i % 24) * 0.5 + # Hourly seasonality
        (i % (24 * 7)) * 0.1 + # Weekly seasonality
        10 + # Base value
        (i / 100)**2 + # Trend
        pd.np.random.randn() * 2 # Noise
        for i in range(1000)
    ]
}
df_raw = pd.DataFrame(data)

# --- Step 1: Load data and parse dates ---
# Assuming 'Date' is a string column like 'YYYY-MM-DD HH:MM:SS'
# In a real CSV, use: df = pd.read_csv('your_data.csv', parse_dates=['Date'])
# For our simulated data, 'Date' is already datetime, so we'll just use it directly.
df = df_raw.copy()
print("Original DataFrame head:")
print(df.head())
print("\nOriginal DataFrame info:")
print(df.info())

# --- Step 2: Set the 'Date' column as the DataFrame index ---
df.set_index('Date', inplace=True)
print("\nDataFrame head after setting index:")
print(df.head())
print("\nDataFrame info after setting index:")
print(df.info())

# --- Step 3: Resample the data (e.g., from hourly to daily mean) ---
# Resampling is crucial for adjusting temporal granularity
# 'D' for daily, 'W' for weekly, 'M' for monthly, 'H' for hourly
df_daily = df['Value'].resample('D').mean()
print("\nDaily resampled data head:")
print(df_daily.head())
print("\nDaily resampled data info:")
print(df_daily.info())

# Plot the original and resampled data to visualize the effect
plt.figure(figsize=(14, 6))
plt.plot(df['Value'], label='Original Hourly Data', alpha=0.7)
plt.plot(df_daily, label='Daily Resampled Mean', color='red')
plt.title('Original vs. Daily Resampled Time Series')
plt.xlabel('Date')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.seasonal import seasonal_decompose
# For better plotting style
import seaborn as sns
sns.set_style("whitegrid")

# Re-using the daily resampled data from the previous step
# Ensure the index is a DatetimeIndex
# If you run this part independently, load data and resample
# df_daily = pd.read_csv('your_data.csv', index_col='Date', parse_dates=True)['Value'].resample('D').mean()
# For demonstration, let's create a slightly different dataset for clearer seasonality
# Or use the df_daily if it's already in scope
if 'df_daily' not in locals(): # Check if df_daily exists from previous cell
    data_decomp = {
        'Date': pd.to_datetime(pd.date_range(start='2020-01-01', periods=365*2, freq='D')),
        'Value': [
            100 + i * 0.1 + # Trend
            pd.np.sin(i / 30 * 2 * pd.np.pi) * 20 + # Monthly seasonality
            pd.np.sin(i / 365 * 2 * pd.np.pi) * 50 + # Yearly seasonality
            pd.np.random.randn() * 10 # Noise
            for i in range(365*2)
        ]
    }
    df_daily = pd.DataFrame(data_decomp).set_index('Date')['Value']

print("DataFrame head for decomposition:")
print(df_daily.head())
print("\nDataFrame info for decomposition:")
print(df_daily.info())

# --- Step 1: Perform time series decomposition ---
# Specify the periodicity for seasonality. For daily data with yearly seasonality, it's 365.25 (approx).
# For monthly seasonality in daily data, it might be 30.
# Let's assume a dominant yearly seasonality for this example.
# Use 'additive' or 'multiplicative' model based on observation (e.g., if seasonal magnitude grows with trend)
decomposition = seasonal_decompose(df_daily, model='additive', period=365) # or period=7 for weekly, etc.

# --- Step 2: Plot the decomposed components ---
plt.figure(figsize=(16, 10))
plt.subplot(411)
plt.plot(df_daily, label='Original Series')
plt.title('Original Time Series')
plt.legend(loc='upper left')

plt.subplot(412)
plt.plot(decomposition.trend, label='Trend')
plt.title('Trend Component')
plt.legend(loc='upper left')

plt.subplot(413)
plt.plot(decomposition.seasonal, label='Seasonality')
plt.title('Seasonal Component')
plt.legend(loc='upper left')

plt.subplot(414)
plt.plot(decomposition.resid, label='Residuals')
plt.title('Residual Component')
plt.legend(loc='upper left')

plt.tight_layout()
plt.show()

# --- Step 3: Calculate and visualize rolling statistics ---
# Rolling mean and standard deviation help smooth out noise and reveal underlying patterns
window_size = 30 # e.g., 30-day rolling window
rolling_mean = df_daily.rolling(window=window_size).mean()
rolling_std = df_daily.rolling(window=window_size).std()

plt.figure(figsize=(14, 6))
plt.plot(df_daily, label='Original Series', alpha=0.7)
plt.plot(rolling_mean, label=f'{window_size}-Day Rolling Mean', color='red')
plt.plot(rolling_std, label=f'{window_size}-Day Rolling Std', color='green', linestyle='--')
plt.title(f'Time Series with {window_size}-Day Rolling Mean and Standard Deviation')
plt.xlabel('Date')
plt.ylabel('Value')
plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.stattools import adfuller
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
import seaborn as sns
sns.set_style("whitegrid")

# Re-using the daily resampled data from previous step, or create a new one for clarity
if 'df_daily' not in locals():
    data_stationarity = {
        'Date': pd.to_datetime(pd.date_range(start='2020-01-01', periods=365*3, freq='D')),
        'Value': [
            100 + i * 0.5 + # Strong trend
            pd.np.sin(i / 30 * 2 * pd.np.pi) * 10 + # Some seasonality
            pd.np.random.randn() * 5 # Noise
            for i in range(365*3)
        ]
    }
    df_daily = pd.DataFrame(data_stationarity).set_index('Date')['Value']

print("Original series head for stationarity analysis:")
print(df_daily.head())

# --- Step 1: Perform Augmented Dickey-Fuller (ADF) test for stationarity ---
def check_stationarity(timeseries):
    """
    Performs the ADF test and prints results.
    """
    print('Results of Augmented Dickey-Fuller Test:')
    dftest = adfuller(timeseries, autolag='AIC')
    dfoutput = pd.Series(dftest[0:4], index=['Test Statistic', 'p-value', '#Lags Used', 'Number of Observations Used'])
    for key, value in dftest[4].items():
        dfoutput['Critical Value (%s)' % key] = value
    print(dfoutput)
    if dfoutput['p-value'] <= 0.05:
        print("--> Series is likely Stationary (Reject H0)")
    else:
        print("--> Series is likely Non-Stationary (Fail to Reject H0)")

print("\n--- ADF Test on Original Series ---")
check_stationarity(df_daily.dropna()) # .dropna() if there are NaNs from decomposition/rolling

# --- Step 2: Apply differencing to achieve stationarity ---
# First-order differencing to remove trend
df_diff1 = df_daily.diff().dropna()
print("\n--- ADF Test on First-Order Differenced Series ---")
check_stationarity(df_diff1)

# If still non-stationary, apply seasonal differencing (e.g., for yearly seasonality with period=365)
# df_diff_seasonal = df_daily.diff(periods=365).dropna()
# print("\n--- ADF Test on Seasonally Differenced Series (period=365) ---")
# check_stationarity(df_diff_seasonal)

# Plot original and differenced series
plt.figure(figsize=(14, 8))
plt.subplot(211)
plt.plot(df_daily, label='Original Series')
plt.title('Original Time Series (Potentially Non-Stationary)')
plt.legend()
plt.subplot(212)
plt.plot(df_diff1, label='First-Order Differenced Series', color='orange')
plt.title('First-Order Differenced Time Series (More Stationary)')
plt.legend()
plt.tight_layout()
plt.show()

# --- Step 3: Plot Autocorrelation (ACF) and Partial Autocorrelation (PACF) ---
# These plots help identify the order of AR and MA components for ARIMA models
plt.figure(figsize=(14, 8))
plt.subplot(211)
plot_acf(df_diff1, lags=30, ax=plt.gca())
plt.title('Autocorrelation Function (ACF) of Differenced Series')

plt.subplot(212)
plot_pacf(df_diff1, lags=30, ax=plt.gca())
plt.title('Partial Autocorrelation Function (PACF) of Differenced Series')

plt.tight_layout()
plt.show()

import pandas as pd
import matplotlib.pyplot as plt
from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_squared_error, mean_absolute_error
from math import sqrt
import seaborn as sns
sns.set_style("whitegrid")

# Re-using the differenced series from previous step, or create a new one
# For ARIMA, the input series should ideally be stationary.
# Let's assume we have a stationary series 'df_diff1'
# If starting fresh, generate data, differencing, etc.
if 'df_diff1' not in locals():
    # Simulate a stationary-ish series for demonstration of ARIMA
    # This might require some previous steps to make it truly stationary
    data_arima = {
        'Date': pd.to_datetime(pd.date_range(start='2020-01-01', periods=365, freq='D')),
        'Value': [
            pd.np.sin(i / 15 * 2 * pd.np.pi) * 5 + # Short cycle seasonality
            pd.np.random.randn() * 2 # Noise
            for i in range(365)
        ]
    }
    df_series = pd.DataFrame(data_arima).set_index('Date')['Value']
    # For a realistic scenario, this would be a differenced series
    df_diff1 = df_series # Using the "stationary-ish" simulated data directly for simplicity

print("Series head for ARIMA modeling (ideally stationary):")
print(df_diff1.head())
print("\nSeries info for ARIMA modeling:")
print(df_diff1.info())

# --- Step 1: Split data into training and testing sets ---
# We use a significant portion for training and a smaller, recent portion for testing
train_size = int(len(df_diff1) * 0.8) # 80% for training
train, test = df_diff1[0:train_size], df_diff1[train_size:]

print(f"\nTraining set size: {len(train)}")
print(f"Testing set size: {len(test)}")

# --- Step 2: Define and fit the ARIMA model ---
# Example orders (p,d,q). These would typically be determined from ACF/PACF plots
# For demonstration, let's pick arbitrary orders that might work for a differenced series.
# If the original series was used, 'd' would be the number of differencing steps.
# Here, we assume 'df_diff1' is already differenced, so d=0 for the ARIMA model itself.
order = (5, 0, 5) # (p, d, q) - AutoRegressive, Integrated, Moving Average orders
# For SARIMA, you would use SARIMAX and add seasonal_order=(P, D, Q, S)
# For this example, we'll stick to basic ARIMA.

print(f"\nFitting ARIMA model with order {order}...")
try:
    model = ARIMA(train, order=order)
    model_fit = model.fit()
    print("Model fitting complete.")
    print(model_fit.summary())
except Exception as e:
    print(f"Error during model fitting: {e}")
    print("Consider adjusting ARIMA orders or checking data for issues (e.g., non-finite values).")
    # Exit or handle gracefully if model fit fails
    # For this example, we'll continue with dummy prediction if fit fails
    model_fit = None

# --- Step 3: Make predictions on the test set ---
if model_fit:
    # Get the start and end dates for prediction
    start_index = len(train)
    end_index = len(df_diff1) - 1
    
    # Predict with confidence intervals
    forecast_results = model_fit.get_forecast(steps=len(test))
    predictions = forecast_results.predicted_mean
    conf_int = forecast_results.conf_int() # Get confidence intervals

    # Ensure predictions have the same index as the test set for comparison
    predictions.index = test.index
    conf_int.index = test.index

    print("\nForecasts generated.")
    print("Predictions head:")
    print(predictions.head())

    # --- Step 4: Evaluate the model ---
    rmse = sqrt(mean_squared_error(test, predictions))
    mae = mean_absolute_error(test, predictions)
    print(f"\nEvaluation Metrics:")
    print(f"Root Mean Squared Error (RMSE): {rmse:.3f}")
    print(f"Mean Absolute Error (MAE): {mae:.3f}")

    # --- Step 5: Visualize actual vs. predicted values ---
    plt.figure(figsize=(14, 7))
    plt.plot(train.index, train, label='Training Data', color='blue')
    plt.plot(test.index, test, label='Actual Test Data', color='green')
    plt.plot(predictions.index, predictions, label='ARIMA Forecast', color='red', linestyle='--')
    plt.fill_between(conf_int.index, conf_int.iloc[:, 0], conf_int.iloc[:, 1], color='pink', alpha=0.3, label='Confidence Interval')
    plt.title('ARIMA Forecast vs. Actuals')
    plt.xlabel('Date')
    plt.ylabel('Value')
    plt.legend()
plt.grid(True)
plt.tight_layout()
plt.show()
else:
    print("\nSkipping prediction and evaluation due to model fitting failure.")

# Important Note: If you used differencing to make the series stationary for ARIMA,
# and you want to forecast the *original* series, you'll need to inverse transform the predictions.
# This involves adding back the last value of the original series to the first differenced prediction,
# and then iteratively adding back the previous original value to subsequent differenced predictions.
# This step is crucial for practical application but adds complexity not covered in this basic example.