# Install necessary libraries
!pip install prophet pandas matplotlib numpy

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from prophet import Prophet

# Suppress warnings for cleaner output
import warnings
warnings.filterwarnings('ignore')

import pandas as pd
import numpy as np

def generate_mock_price_data(start_date='2020-01-01', periods=730, initial_price=100, trend_strength=0.05, seasonality_amplitude_base=5, volatility=2, spike_frequency=0.02, spike_magnitude=10):
    """
    Generates more realistic mock daily price data with trend, seasonality, noise, and occasional spikes.

    Inputs:
        start_date (str): Start date for the time series.
        periods (int): Number of days to generate data for.
        initial_price (float): Starting price.
        trend_strength (float): Overall strength of the linear trend component.
        seasonality_amplitude_base (float): Base amplitude for seasonal components.
        volatility (float): Standard deviation for daily random price changes.
        spike_frequency (float): Probability of a random spike/drop occurring on any given day.
        spike_magnitude (float): Maximum magnitude of a random spike/drop.

    Outputs:
        pd.DataFrame: A DataFrame with 'ds' and 'y' columns.
    """
    dates = pd.date_range(start=start_date, periods=periods, freq='D')
    time_index = np.arange(periods)

    # 1. Base Trend: A general upward trend, but not perfectly linear
    # Using a slightly curved trend to make it less obvious
    base_trend = initial_price + trend_strength * time_index + 5 * np.sin(time_index / 100)

    # 2. Weekly Seasonality: More complex than a single sine wave
    weekly_seasonality = (
        seasonality_amplitude_base * np.sin(2 * np.pi * (time_index % 7) / 7) +
        (seasonality_amplitude_base / 2) * np.cos(2 * np.pi * (time_index % 7) / 7 + np.pi/4)
    )

    # 3. Yearly Seasonality: More complex
    yearly_seasonality = (
        seasonality_amplitude_base * 1.5 * np.sin(2 * np.pi * time_index / 365) +
        (seasonality_amplitude_base / 2) * np.cos(2 * np.pi * time_index / (365/2) + np.pi/2)
    )

    # 4. Random Walk / Daily Price Changes (autocorrelation)
    # Each day's price change is a small random step
    daily_changes = np.random.normal(0, volatility, periods).cumsum()

    # 5. Occasional Spikes/Drops
    spikes = np.zeros(periods)
    for i in range(periods):
        if np.random.rand() < spike_frequency:
            # Randomly choose between a spike or a drop
            spike_direction = 1 if np.random.rand() > 0.5 else -1
            spikes[i] = spike_direction * np.random.uniform(spike_magnitude / 2, spike_magnitude)

    # Combine components
    prices = base_trend + weekly_seasonality + yearly_seasonality + daily_changes + spikes
    prices = np.maximum(5, prices) # Ensure prices are non-negative and have a floor

    df = pd.DataFrame({
        'ds': dates,
        'y': prices
    })
    return df

# Generate sample price data for 2 years with revised parameters
df_price = generate_mock_price_data(periods=730, initial_price=100, trend_strength=0.08, seasonality_amplitude_base=7, volatility=1.5, spike_frequency=0.03, spike_magnitude=15)
display(df_price.head())
display(df_price.tail())

# Initialize Prophet model
# We explicitly set yearly and weekly seasonality to True as our data has these components.
# For financial data, 'multiplicative' seasonality might sometimes be more appropriate if the seasonal effect scales with the trend.
# Here, we'll start with 'additive' which is the default.
m = Prophet(yearly_seasonality=True, weekly_seasonality=True, daily_seasonality=False)

# Fit the model to the historical data
m.fit(df_price)

print("Prophet model fitted successfully!")

# Create a DataFrame with future dates for forecasting
# Let's forecast for the next 365 days (1 year)
future = m.make_future_dataframe(periods=365)

# Make predictions
forecast = m.predict(future)

print("Forecast DataFrame head:")
display(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].head())

print("\nForecast DataFrame tail (showing future predictions):")
display(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail())

# Plot the overall forecast
fig1 = m.plot(forecast, figsize=(10, 6))
plt.title('Prophet Price Forecast (Historical + Predicted)')
plt.xlabel('Date')
plt.ylabel('Price')
plt.grid(True)
plt.show()

# Interpretation:
# The black dots represent the actual historical price data.
# The blue line represents the Prophet model's fit to the historical data and its forecast into the future.
# The light blue shaded area indicates the uncertainty interval (yhat_lower to yhat_upper) for the predictions.
# This visualization helps to see how well the model captures the historical trend and seasonality, and where it predicts the price will go.

# Plot the forecast components
fig2 = m.plot_components(forecast, figsize=(10, 8))
plt.suptitle('Prophet Forecast Components', y=1.02) # Add a main title for all subplots
plt.tight_layout(rect=[0, 0.03, 1, 0.98]) # Adjust layout to prevent title overlap
plt.show()

# Interpretation:
# The top plot shows the overall trend identified by Prophet, which appears to be increasing over time in our mock data.
# The middle plot illustrates the yearly seasonality. For our mock data, there's a clear sinusoidal pattern, representing price fluctuations over a year.
# The bottom plot displays the weekly seasonality. This indicates typical price behavior on each day of the week, e.g., potentially higher prices on weekends or specific weekdays.

# Example: Adding custom holidays
# Create a DataFrame of holidays (e.g., a 'Black Friday' effect)
holidays = pd.DataFrame({
    'holiday': 'black_friday',
    'ds': pd.to_datetime(['2020-11-27', '2021-11-26']),
    'lower_window': 0,
    'upper_window': 1,
})

# Initialize Prophet with holidays
m_holidays = Prophet(holidays=holidays, yearly_seasonality=True, weekly_seasonality=True)
m_holidays.fit(df_price)
future_holidays = m_holidays.make_future_dataframe(periods=365)
forecast_holidays = m_holidays.predict(future_holidays)

print("Forecast with Black Friday holiday effect:")
display(forecast_holidays[['ds', 'yhat', 'black_friday']].tail())

# You can also plot the holiday components:
fig_holidays = m_holidays.plot_components(forecast_holidays)
plt.show()