!pip install pandas numpy

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

import plotly.graph_objects as go

def generate_data(periods: int) -> pd.DataFrame:
    """Generates a larger synthetic OHLCV dataset with more realistic price fluctuations."""
    start_date = pd.to_datetime("2024-01-01 00:00:00+00:00")
    datetime_index = pd.date_range(start_date, periods=periods, freq="1min", tz="UTC")

    price_data = []
    last_close = 42000 # Starting price
    volatility_scale = 0.005 # Controls the general magnitude of price changes
    wick_deviation_scale = 0.002 # Controls how much wicks extend beyond body

    for i in range(periods):
        # Open price drifts slightly from the previous close
        open_price = last_close + np.random.normal(0, last_close * volatility_scale * 0.1)

        # Simulate a price change to determine the closing price
        price_change = np.random.normal(0, last_close * volatility_scale)
        close_price = open_price + price_change

        # Determine the high and low of the candle body
        body_high = max(open_price, close_price)
        body_low = min(open_price, close_price)

        # Simulate wicks extending beyond the body
        # High wick should be above the body_high
        high_wick_extension = np.abs(np.random.normal(0, last_close * wick_deviation_scale))
        high_price = body_high + high_wick_extension

        # Low wick should be below the body_low
        low_wick_extension = np.abs(np.random.normal(0, last_close * wick_deviation_scale))
        low_price = body_low - low_wick_extension

        # Ensure OHLC integrity: High must be the absolute highest, Low the absolute lowest
        high_price = max(high_price, open_price, close_price)
        low_price = min(low_price, open_price, close_price)

        # Ensure High is never less than Low
        if high_price < low_price:
            high_price, low_price = low_price, high_price # Swap if somehow invalid

        # Ensure all values are positive integers
        open_price = max(1, int(open_price))
        high_price = max(1, int(high_price))
        low_price = max(1, int(low_price))
        close_price = max(1, int(close_price))

        price_data.append({
            "open": open_price,
            "high": high_price,
            "low": low_price,
            "close": close_price
        })
        last_close = close_price # Update last_close for the next iteration

    df_large = pd.DataFrame(price_data, index=datetime_index)
    df_large.index.name = "datetime"

    # Simulate volume with some fluctuation
    df_large["volume"] = np.random.uniform(100.0, 500.0, periods)

    return df_large

periods = 500 # Generate 500 data points
df_large = generate_data(periods)
df_large["datetime"] = df_large.index.to_series()
df_large = df_large.reset_index(drop=True)

def ema_ribbon_strategy(
    df:      pd.DataFrame,
    periods: list = [20, 30, 40, 50, 60],
) -> pd.DataFrame:
    df = df.copy().sort_values("datetime", ignore_index=True)

    ema_cols = []
    for p in periods:
        col = f"ema_{p}"
        df[col] = df["close"].ewm(span=p, adjust=False).mean()
        ema_cols.append(col)

    # Ribbon is bullish when each EMA is above the next longer EMA
    df["ribbon_bullish"] = all(
        (df[ema_cols[i]] > df[ema_cols[i+1]]).all()
        for i in range(len(ema_cols)-1)
    )

    ema_values = df[ema_cols]
    df["ribbon_aligned_bull"] = (ema_values.diff(axis=1).iloc[:, 1:] < 0).all(axis=1)
    df["ribbon_aligned_bear"] = (ema_values.diff(axis=1).iloc[:, 1:] > 0).all(axis=1)

    df["signal"] = np.where(
        df["ribbon_aligned_bull"],  1,
        np.where(df["ribbon_aligned_bear"], -1, 0)
    )

    return df[["datetime", "close"] + ema_cols + ["signal"]]

# Prepare df_indicators_large for plotting
df_indicators_large = df_large.copy()

# Calculate SMA_10
df_indicators_large["sma_10"] = df_indicators_large["close"].rolling(window=10).mean()

# Apply the EMA ribbon strategy to get EMA values for the larger dataset
df_ema_results = ema_ribbon_strategy(df_large)

# Merge ema_20 and signal from the results into df_indicators_large
df_indicators_large = pd.merge(
    df_indicators_large,
    df_ema_results[['datetime', 'ema_20', 'signal']],
    on='datetime',
    how='left'
)

print("--- Indicators (Large Dataset) ---")
display(df_indicators_large.tail(10))

fig = go.FigureWidget(data=[
    go.Candlestick(
        x=df_indicators_large["datetime"],
        open=df_indicators_large['open'],
        high=df_indicators_large['high'],
        low=df_indicators_large['low'],
        close=df_indicators_large['close'],
        name='Price'
    )
])

# Add SMA_10
fig.add_trace(
go.Scatter(
    x=df_indicators_large["datetime"],
    y=df_indicators_large['sma_10'],
    mode='lines',
    name='SMA 10',
    line=dict(color='blue', width=1)
))

# Add EMA_20 (changed from EMA_10)
fig.add_trace(
go.Scatter(
    x=df_indicators_large["datetime"],
    y=df_indicators_large['ema_20'], # Changed from 'ema_10'
    mode='lines',
    name='EMA 20', # Changed from 'EMA 10'
    line=dict(color='orange', width=1)
))

# Add Buy Signals
buy_signals = df_indicators_large[df_indicators_large['signal'] == 1]
fig.add_trace(go.Scatter(
    x=buy_signals['datetime'],
    y=buy_signals['low'] * 0.99, # Plot below the low price
    mode='markers',
    marker=dict(symbol='triangle-up', size=10, color='green'),
    name='Buy Signal'
))

# Add Sell Signals
sell_signals = df_indicators_large[df_indicators_large['signal'] == -1]
fig.add_trace(go.Scatter(
    x=sell_signals['datetime'],
    y=sell_signals['high'] * 1.01, # Plot above the high price
    mode='markers',
    marker=dict(symbol='triangle-down', size=10, color='red'),
    name='Sell Signal'
))

fig.update_layout(
    title_text='Candlestick Chart with SMA, EMA, and Trading Signals',
    xaxis_rangeslider_visible=False,
    xaxis_title='Date',
    yaxis_title='Price',
    height=600,
    yaxis=dict(autorange=True) # Ensure y-axis scales to visible candles
)

fig.show()