!pip install pandas numpy

import warnings
warnings.filterwarnings("ignore")

import pandas as pd
import numpy as np

raw_data = {
    "datetime": pd.date_range("2024-01-01", periods=30, freq="1min", tz="UTC"),
    "close": [42200,42150,42300,42250,42400,42350,42500,42450,42600,42550,
              42700,42650,42800,42750,42900,42850,43000,42950,43100,43050,
              43200,43150,43300,43250,43400,43350,43500,43450,43600,43550],
}

df = pd.DataFrame(raw_data)
df["datetime"] = pd.to_datetime(df["datetime"], utc=True)

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)

print("--- Generated OHLCV Data ---")
display(df_large.head())

df_indicators_large = df_large.copy()

df_indicators_large['sma_10'] = df_indicators_large['close'].rolling(window=10).mean()
df_indicators_large['ema_10'] = df_indicators_large['close'].ewm(span=10, adjust=False).mean()

print("--- OHLCV Data with SMA and EMA ---")
display(df_indicators_large.head(20))

def ma_crossover_strategy(
    df_data:     pd.DataFrame,
    fast_window: int = 5,
    slow_window: int = 15,
) -> pd.DataFrame:
    df_data = df_data.copy().sort_values("datetime", ignore_index=True)

    df_data["fast_ma"] = df_data["close"].rolling(fast_window).mean()
    df_data["slow_ma"] = df_data["close"].rolling(slow_window).mean()

    # Signal: +1 when fast is above slow (bullish), -1 when below (bearish)
    df_data["signal"] = np.where(df_data["fast_ma"] > df_data["slow_ma"], 1, -1)

    # Crossover event: signal changes from previous row
    df_data["crossover"] = df_data["signal"].diff().ne(0) & df_data["signal"].notna()

    # Entry type at each crossover
    df_data["entry"] = np.where(
        df_data["crossover"] & (df_data["signal"] == 1),  "BUY",
        np.where(
        df_data["crossover"] & (df_data["signal"] == -1), "SELL", None)
    )

    return df_data[["datetime", "close", "fast_ma", "slow_ma", "signal", "crossover", "entry"]]

df_signals_large = ma_crossover_strategy(df_large, fast_window=10, slow_window=30)

print("--- MA Crossover Signals (for large dataset) ---")
display(df_signals_large.head())
print("\nEntries only:")
display(df_signals_large[df_signals_large["entry"].notna()])

import plotly.graph_objects as go

# Merge df_indicators_large with df_signals_large to get signals in one DataFrame
df_combined_plot = pd.merge(df_indicators_large, df_signals_large[['datetime', 'entry']], on='datetime', how='left')

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

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

# Add EMA_10
fig.add_trace(go.Scatter(
    x=df_combined_plot["datetime"],
    y=df_combined_plot['ema_10'],
    mode='lines',
    name='EMA 10',
    line=dict(color='orange', width=1)
))

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

# Add Sell Signals
sell_signals = df_combined_plot[df_combined_plot['entry'] == 'SELL']
fig.add_trace(go.Scatter(
    x=sell_signals['datetime'],
    y=sell_signals['high'] * 1.01, # Plot above the high of the candle
    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 Crossover Signals',
    xaxis_rangeslider_visible=False,
    xaxis_title='Date',
    yaxis_title='Price',
    height=700,
    yaxis=dict(autorange=True),
    showlegend=True, # Ensure legend is visible
    legend=dict(x=1.02, y=1, xanchor='left', yanchor='top') # Position legend outside the plot
)

fig.show()