sp500

sp500.index

sp500.plot.line(y="Close", use_index=True)

sp500

sp500

sp500

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

# Split the data without shuffling to maintain temporal order
train, test = train_test_split(sp500, test_size=0.1, shuffle=False)

# Define your predictors and train the Random Forest
predictors = ['Close', 'Volume', 'Open', 'High', 'Low']
model = RandomForestClassifier(n_estimators=100, min_samples_split=100, random_state=1)
model.fit(train[predictors], train["Target"])

preds

precision_score(test["Target"], preds)

combined.plot()

predictions["Predictions"].value_counts()

precision_score(predictions["Target"], predictions["Predictions"])

predictions["Target"].value_counts() / predictions.shape[0]

sp500

predictions["Predictions"].value_counts()

precision_score(predictions["Target"], predictions["Predictions"])

# Define a function to calculate RSI
def calculate_rsi(data, window=14):
    delta = data['Close'].diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)

    avg_gain = gain.rolling(window=window).mean()
    avg_loss = loss.rolling(window=window).mean()

    rs = avg_gain / avg_loss
    rsi = 100 - (100 / (1 + rs))

    return rsi

# Add RSI to your DataFrame using .loc to avoid SettingWithCopyWarning
sp500.loc[:, 'RSI'] = calculate_rsi(sp500)

# Verify that RSI is added correctly
print(sp500[['Close', 'RSI']].head())

nan_rsi_count = sp500['RSI'].isna().sum()
print(nan_rsi_count)

sp500['RSI'] = sp500['RSI'].fillna(method='bfill')
nan_rsi_count = sp500['RSI'].isna().sum()
print(nan_rsi_count)

# Drop the 'RSI' column from predictions if it already exists
if 'RSI' in predictions.columns:
    predictions = predictions.drop(columns=['RSI'])

# Merge the RSI column into the predictions DataFrame
predictions = predictions.merge(sp500[['RSI']], left_index=True, right_index=True)

# Define the conditions for buy/sell based on model prediction and RSI
buy_condition = (predictions['Predictions'] == 1) & (predictions['RSI'] < 10)
sell_condition = (predictions['Predictions'] == 0) & (predictions['RSI'] > 90)

# Create new columns for filtered buy/sell signals
predictions['Filtered_Signal'] = 0  # Default to 'hold' (no action)
predictions.loc[buy_condition, 'Filtered_Signal'] = 1  # Buy signal
predictions.loc[sell_condition, 'Filtered_Signal'] = -1  # Sell signal

# Display the filtered signals for reference
print(predictions[['Predictions', 'Filtered_Signal', 'RSI']].head())

count_buy = (predictions['Filtered_Signal'] == 1).sum()
count_sell = (predictions['Filtered_Signal'] == -1).sum()
print(f"Number of 'Buy' signals: {count_buy}")
print(f"Number of 'Sell' signals: {count_sell}")

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Initialize values
initial_balance = 20000  # Starting balance of $20,000
balance = initial_balance
shares = 0
balance_over_time = []

# Trade log to track each trade
trade_log = pd.DataFrame(columns=['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss'])

# Use sp500 DataFrame for this
sp500 = sp500.copy()
sp500['Buy_Signal'] = (sp500['MACD'] > sp500['Signal_Line'])  # MACD Cross up
sp500['Sell_Signal'] = (sp500['MACD'] < sp500['Signal_Line']) & (sp500['RSI'] > 70)  # MACD Cross down + RSI > 70

# Initialize columns for tracking
sp500['Portfolio_Value'] = np.nan
sp500['Balance'] = np.nan
sp500['Shares_Held'] = np.nan

# Simulate the paper trading
for i, row in sp500.iterrows():
    close_price = row['Close']
    trade_date = row.name
    amount_to_invest = 0.1 * balance  # Recalculate 10% of the balance each time

    if row['Buy_Signal'] and shares == 0:  # Buy signal - invest 10% of balance
        shares_to_buy = amount_to_invest // close_price  # Calculate the number of shares to buy
        shares_bought = shares_to_buy  # Whole shares only

        if shares_bought > 0:  # Only proceed if we actually bought shares
            shares += shares_bought
            balance -= shares_bought * close_price  # Update balance based on actual share purchase

            # Log the trade
            new_trade = pd.DataFrame({
                'Date': [trade_date],
                'Action': ['Buy'],
                'Shares': [shares_bought],
                'Price': [close_price],
                'Balance': [balance],
                'Portfolio Value': [balance + (shares * close_price)],
                'Profit/Loss': [0]  # No profit or loss on buy
            })
            trade_log = pd.concat([trade_log, new_trade], ignore_index=True)

    elif row['Sell_Signal'] and shares > 0:  # Sell signal - sell all shares if RSI > 70
        sell_value = shares * close_price
        balance += sell_value

        # Calculate the profit/loss
        buy_price = trade_log.iloc[-1]['Price']  # Get the last buy price
        profit_loss = (close_price - buy_price) * shares

        # Log the trade
        new_trade = pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Sell'],
            'Shares': [shares],
            'Price': [close_price],
            'Balance': [balance],
            'Portfolio Value': [balance],
            'Profit/Loss': [profit_loss]
        })
        trade_log = pd.concat([trade_log, new_trade], ignore_index=True)

        shares = 0  # Sell all shares

    # Record portfolio value (balance + value of held shares)
    portfolio_value = balance + (shares * close_price)
    balance_over_time.append(portfolio_value)

    # Update the DataFrame with current values
    sp500.at[i, 'Portfolio_Value'] = portfolio_value
    sp500.at[i, 'Balance'] = balance
    sp500.at[i, 'Shares_Held'] = shares

# Final balance after all trades
final_balance = balance + (shares * sp500['Close'].iloc[-1])  # If holding shares, sell at last close price
profit = final_balance - initial_balance

# Print final results
print(f"Final Balance: ${final_balance:.2f}")
print(f"Total Profit: ${profit:.2f}")

# Convert balance over time to pandas series for plotting
balance_over_time = pd.Series(balance_over_time, index=sp500.index[:len(balance_over_time)])

# Plotting Portfolio Value vs S&P 500 Close Price
plt.figure(figsize=(12, 6))
plt.plot(sp500.index, sp500['Portfolio_Value'], label='Portfolio Value', color='cyan')
plt.plot(sp500.index, sp500['Close'], label='S&P 500 Close Price', color='magenta', alpha=0.5)
plt.title('Portfolio Value vs S&P 500 Close Price')
plt.xlabel('Date')
plt.ylabel('Value ($)')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Trade summary
total_trades = len(trade_log[trade_log['Shares'] > 0])  # Only count trades with shares > 0
winning_trades = trade_log[trade_log['Profit/Loss'] > 0]
losing_trades = trade_log[trade_log['Profit/Loss'] < 0]
print(f"Total Trades: {total_trades}")
print(f"Winning Trades: {len(winning_trades)}")
print(f"Losing Trades: {len(losing_trades)}")

# Plotting Profit/Loss of each trade
plt.figure(figsize=(12, 6))
trade_log['Profit/Loss'].plot(kind='bar', color=['green' if x > 0 else 'red' for x in trade_log['Profit/Loss']])
plt.title('Profit/Loss of Each Trade')
plt.ylabel('Profit/Loss ($)')
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Display the trade log with Profit/Loss
print(trade_log[['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss']])

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Initialize values
initial_balance = 20000  # Starting balance of $20,000
balance = initial_balance
shares = 0
amount_to_invest = 0.1 * balance  # Invest 10% of balance on each trade
balance_over_time = []

# Trade log to track each trade
trade_log = pd.DataFrame(columns=['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss'])

# Calculate the MACD (Moving Average Convergence Divergence)
short_window = 12  # Short-term EMA (e.g., 12-period EMA)
long_window = 26  # Long-term EMA (e.g., 26-period EMA)
signal_window = 9  # Signal line (e.g., 9-period EMA of MACD line)

# Calculate MACD and Signal Line
sp500['MACD'] = sp500['Close'].ewm(span=short_window, adjust=False).mean() - sp500['Close'].ewm(span=long_window, adjust=False).mean()
sp500['Signal_Line'] = sp500['MACD'].ewm(span=signal_window, adjust=False).mean()

# Calculate MACD Histogram (MACD - Signal Line)
sp500['MACD_Histogram'] = sp500['MACD'] - sp500['Signal_Line']

# Initialize columns for tracking
sp500['Portfolio_Value'] = np.nan
sp500['Balance'] = np.nan
sp500['Shares_Held'] = np.nan

# Simulate the paper trading based on MACD Histogram signals
for i, row in sp500.iterrows():
    close_price = row['Close']
    trade_date = row.name

    # Calculate amount to invest (10% of the current balance)
    amount_to_invest = 0.1 * balance

    # Buy when MACD histogram crosses above 0
    if row['MACD_Histogram'] > 0 and shares == 0:
        shares_to_buy = amount_to_invest // close_price  # Buy whole shares only

        # Only execute the trade if shares_to_buy is greater than 0
        if shares_to_buy > 0:
            shares += shares_to_buy
            balance -= shares_to_buy * close_price

            # Log the trade
            new_trade = pd.DataFrame({
                'Date': [trade_date],
                'Action': ['Buy'],
                'Shares': [shares],
                'Price': [close_price],
                'Balance': [balance],
                'Portfolio Value': [balance + (shares * close_price)],
                'Profit/Loss': [0]  # Set profit/loss to 0 for now; we'll calculate it after sell
            })
            trade_log = pd.concat([trade_log, new_trade], ignore_index=True)

    # Sell when MACD histogram crosses below 0 and RSI is greater than 70 (overbought)
    elif row['MACD_Histogram'] < 0 and shares > 0 and row['RSI'] > 70:
        balance += shares * close_price

        # Calculate profit/loss for the trade
        buy_price = trade_log.loc[trade_log['Action'] == 'Buy', 'Price'].iloc[-1] if len(trade_log) > 0 else 0
        profit_loss = (close_price - buy_price) * shares

        # Log the trade
        new_trade = pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Sell'],
                'Shares': [shares],
                'Price': [close_price],
                'Balance': [balance],
                'Portfolio Value': [balance],
                'Profit/Loss': [profit_loss]
            })
        trade_log = pd.concat([trade_log, new_trade], ignore_index=True)

        shares = 0  # Reset shares to 0 after selling

    # Record portfolio value (balance + value of held shares)
    portfolio_value = balance + (shares * close_price)
    balance_over_time.append(portfolio_value)

    # Update the DataFrame with current values
    sp500.at[i, 'Portfolio_Value'] = portfolio_value
    sp500.at[i, 'Balance'] = balance
    sp500.at[i, 'Shares_Held'] = shares

# Final balance after all trades
final_balance = balance + (shares * sp500['Close'].iloc[-1])  # If holding shares, sell at last close price
profit = final_balance - initial_balance

# Print final results
print(f"Final Balance: ${final_balance:.2f}")
print(f"Total Profit: ${profit:.2f}")

# Convert balance over time to pandas series for plotting
balance_over_time = pd.Series(balance_over_time, index=sp500.index[:len(balance_over_time)])

# Plotting Portfolio Value and P/L
plt.figure(figsize=(12, 6))
plt.plot(sp500.index, sp500['Portfolio_Value'], label='Portfolio Value', color='cyan')
plt.plot(sp500.index, sp500['Close'], label='S&P 500 Close Price', color='magenta', alpha=0.5)
plt.title('Portfolio Value vs S&P 500 Close Price')
plt.xlabel('Date')
plt.ylabel('Value ($)')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Display the profit/loss per trade
trade_log['Profit/Loss'] = trade_log['Profit/Loss'].fillna(0)  # Ensure no NaN values in P/L
trade_log.reset_index(drop=True, inplace=True)

# Plot Profit/Loss for each trade
plt.figure(figsize=(12, 6))
trade_log['Profit/Loss'].plot(kind='bar', color=['green' if x > 0 else 'red' for x in trade_log['Profit/Loss']])
plt.title('Profit/Loss of Each Trade')
plt.ylabel('Profit/Loss ($)')
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Print trade summary
total_trades = len(trade_log) // 2  # Buy/Sell count as one trade
winning_trades = len(trade_log[trade_log['Profit/Loss'] > 0]) // 2
losing_trades = len(trade_log[trade_log['Profit/Loss'] < 0]) // 2

print(f"Total Trades: {total_trades}")
print(f"Winning Trades: {winning_trades}")
print(f"Losing Trades: {losing_trades}")

# Display trade log
print(trade_log[['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss']])

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Bollinger Bands Parameters
window = 20  # Typical period for Bollinger Bands
std_dev = 2  # Standard deviation multiplier

# Calculate Bollinger Bands
sp500['Rolling_Mean'] = sp500['Close'].rolling(window).mean()
sp500['Rolling_Std'] = sp500['Close'].rolling(window).std()
sp500['Bollinger_Upper'] = sp500['Rolling_Mean'] + (std_dev * sp500['Rolling_Std'])
sp500['Bollinger_Lower'] = sp500['Rolling_Mean'] - (std_dev * sp500['Rolling_Std'])

# Initialize variables for simulation
initial_balance = 20000
balance = initial_balance
shares = 0
amount_to_invest = 0.1 * balance  # 10% of current balance
balance_over_time = []

# Trade log to track each trade
trade_log = pd.DataFrame(columns=['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value'])

# Simulate the Bollinger Bands Strategy
for i, row in sp500.iterrows():
    close_price = row['Close']
    trade_date = row.name

    # Buy signal - price crosses below the lower band and we are not holding shares
    if close_price < row['Bollinger_Lower'] and shares == 0:
        shares_to_buy = (amount_to_invest // close_price) * close_price
        shares += shares_to_buy // close_price
        balance -= shares_to_buy

        # Log the trade
        new_trade = pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Buy'],
            'Shares': [shares],
            'Price': [close_price],
            'Balance': [balance],
            'Portfolio Value': [balance + (shares * close_price)]
        })
        trade_log = pd.concat([trade_log, new_trade], ignore_index=True)

    # Sell signal - price crosses above the upper band and we are holding shares
    elif close_price > row['Bollinger_Upper'] and shares > 0:
        balance += shares * close_price

        # Log the trade
        new_trade = pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Sell'],
            'Shares': [shares],
            'Price': [close_price],
            'Balance': [balance],
            'Portfolio Value': [balance]
        })
        trade_log = pd.concat([trade_log, new_trade], ignore_index=True)

        shares = 0  # Reset shares after selling

    # Record portfolio value (balance + value of held shares)
    portfolio_value = balance + (shares * close_price)
    balance_over_time.append(portfolio_value)

    # Update the DataFrame with current values
    sp500.at[i, 'Portfolio_Value'] = portfolio_value
    sp500.at[i, 'Balance'] = balance
    sp500.at[i, 'Shares_Held'] = shares

# Final balance after all trades
final_balance = balance + (shares * sp500['Close'].iloc[-1])  # If holding shares, sell at last close price
profit = final_balance - initial_balance

# Print final results
print(f"Final Balance: ${final_balance:.2f}")
print(f"Total Profit: ${profit:.2f}")

# Convert balance over time to pandas series for plotting
balance_over_time = pd.Series(balance_over_time, index=sp500.index[:len(balance_over_time)])

# Plotting Portfolio Value vs S&P 500 Close Price
plt.figure(figsize=(12, 6))
plt.plot(sp500.index, sp500['Portfolio_Value'], label='Portfolio Value', color='cyan')
plt.plot(sp500.index, sp500['Close'], label='S&P 500 Close Price', color='magenta', alpha=0.5)
plt.plot(sp500.index, sp500['Bollinger_Upper'], label='Upper Bollinger Band', color='green', linestyle='--', alpha=0.6)
plt.plot(sp500.index, sp500['Bollinger_Lower'], label='Lower Bollinger Band', color='red', linestyle='--', alpha=0.6)
plt.title('Portfolio Value vs S&P 500 Close Price with Bollinger Bands')
plt.xlabel('Date')
plt.ylabel('Value ($)')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Display Profit/Loss of each trade
trade_log['Profit/Loss'] = 0
for i in range(1, len(trade_log), 2):
    buy_price = trade_log.loc[i-1, 'Price']
    sell_price = trade_log.loc[i, 'Price']
    shares = trade_log.loc[i-1, 'Shares']
    profit_loss = (sell_price - buy_price) * shares
    trade_log.at[i, 'Profit/Loss'] = profit_loss

# Plotting Profit/Loss for each trade
plt.figure(figsize=(12, 6))
trade_log['Profit/Loss'].plot(kind='bar', color=['green' if x > 0 else 'red' for x in trade_log['Profit/Loss']])
plt.title('Profit/Loss of Each Trade')
plt.ylabel('Profit/Loss ($)')
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Summary of trades
total_trades = len(trade_log) // 2  # Each trade consists of a Buy and Sell
winning_trades = len(trade_log[trade_log['Profit/Loss'] > 0]) // 2
losing_trades = len(trade_log[trade_log['Profit/Loss'] < 0]) // 2
print(f"Total Trades: {total_trades}")
print(f"Winning Trades: {winning_trades}")
print(f"Losing Trades: {losing_trades}")

# Display trade log
print(trade_log[['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss']])

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# Initialize values
initial_balance = 500  # Starting balance of $20,000
balance = initial_balance
balance_over_time = []

# Track open trades for each strategy
open_trades = {'MACD Crossover': False, 'MACD Histogram': False, 'Bollinger Bands': False, 'Golden Cross/Death Cross': False}
shares_held = {'MACD Crossover': 0, 'MACD Histogram': 0, 'Bollinger Bands': 0, 'Golden Cross/Death Cross': 0}

# Trade log to track each trade
trade_log = pd.DataFrame(columns=['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss', 'Strategy'])

# Simulate the paper trading for each strategy (example: MACD Crossover, Bollinger Bands, etc.)
for i, row in sp500.iterrows():
    close_price = row['Close']
    trade_date = row.name
    amount_to_invest = 1 * balance  # Recalculate 10% of the balance each time

    ### MACD Crossover Strategy ###
    if row['MACD'] > row['Signal_Line'] and not open_trades['MACD Crossover']:  # Buy signal
        shares_to_buy = amount_to_invest // close_price
        if shares_to_buy > 0:
            open_trades['MACD Crossover'] = True
            shares_held['MACD Crossover'] = shares_to_buy
            balance -= shares_to_buy * close_price

            # Log the buy trade
            trade_log = pd.concat([trade_log, pd.DataFrame({
                'Date': [trade_date],
                'Action': ['Buy'],
                'Shares': [shares_to_buy],
                'Price': [close_price],
                'Balance': [balance],
                'Portfolio Value': [balance + (shares_to_buy * close_price)],
                'Profit/Loss': [0],  # No profit/loss for a buy
                'Strategy': ['MACD Crossover']
            })], ignore_index=True)

    elif row['MACD'] < row['Signal_Line'] and row['RSI'] > 70 and open_trades['MACD Crossover']:  # Sell signal
        sell_value = shares_held['MACD Crossover'] * close_price
        balance += sell_value

        # Calculate the profit/loss
        buy_price = trade_log.loc[trade_log['Strategy'] == 'MACD Crossover', 'Price'].iloc[-1]
        profit_loss = (close_price - buy_price) * shares_held['MACD Crossover']

        # Log the sell trade
        trade_log = pd.concat([trade_log, pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Sell'],
            'Shares': [shares_held['MACD Crossover']],
            'Price': [close_price],
            'Balance': [balance],
            'Portfolio Value': [balance],
            'Profit/Loss': [profit_loss],
            'Strategy': ['MACD Crossover']
        })], ignore_index=True)

        open_trades['MACD Crossover'] = False  # Reset to allow future trades
        shares_held['MACD Crossover'] = 0  # Reset shares after selling

    ### Bollinger Bands Strategy ###
    if close_price < row['Bollinger_Lower'] and not open_trades['Bollinger Bands']:  # Buy signal
        shares_to_buy = amount_to_invest // close_price
        if shares_to_buy > 0:
            open_trades['Bollinger Bands'] = True
            shares_held['Bollinger Bands'] = shares_to_buy
            balance -= shares_to_buy * close_price

            # Log the buy trade
            trade_log = pd.concat([trade_log, pd.DataFrame({
                'Date': [trade_date],
                'Action': ['Buy'],
                'Shares': [shares_to_buy],
                'Price': [close_price],
                'Balance': [balance],
                'Portfolio Value': [balance + (shares_to_buy * close_price)],
                'Profit/Loss': [0],  # No profit/loss for a buy
                'Strategy': ['Bollinger Bands']
            })], ignore_index=True)

    elif close_price > row['Bollinger_Upper'] and open_trades['Bollinger Bands']:  # Sell signal
        sell_value = shares_held['Bollinger Bands'] * close_price
        balance += sell_value

        # Calculate the profit/loss
        buy_price = trade_log.loc[trade_log['Strategy'] == 'Bollinger Bands', 'Price'].iloc[-1]
        profit_loss = (close_price - buy_price) * shares_held['Bollinger Bands']

        # Log the sell trade
        trade_log = pd.concat([trade_log, pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Sell'],
            'Shares': [shares_held['Bollinger Bands']],
            'Price': [close_price],
            'Balance': [balance],
            'Portfolio Value': [balance],
            'Profit/Loss': [profit_loss],
            'Strategy': ['Bollinger Bands']
        })], ignore_index=True)

        open_trades['Bollinger Bands'] = False  # Reset to allow future trades
        shares_held['Bollinger Bands'] = 0  # Reset shares after selling

    # Record portfolio value (balance + value of held shares)
    portfolio_value = balance + (shares_held['MACD Crossover'] * close_price) + (shares_held['Bollinger Bands'] * close_price)
    balance_over_time.append(portfolio_value)

# Final balance after all trades
final_balance = balance + (shares_held['MACD Crossover'] * sp500['Close'].iloc[-1]) + (shares_held['Bollinger Bands'] * sp500['Close'].iloc[-1])
profit = final_balance - initial_balance

# Print final results
print(f"Final Balance: ${final_balance:.2f}")
print(f"Total Profit: ${profit:.2f}")

# Convert balance over time to pandas series for plotting
balance_over_time = pd.Series(balance_over_time, index=sp500.index[:len(balance_over_time)])

# Plotting Portfolio Value vs S&P 500 Close Price
plt.figure(figsize=(12, 6))
plt.plot(sp500.index, balance_over_time, label='Portfolio Value', color='cyan')
plt.plot(sp500.index, sp500['Close'], label='S&P 500 Close Price', color='magenta', alpha=0.5)
plt.title('Portfolio Value vs S&P 500 Close Price')
plt.xlabel('Date')
plt.ylabel('Value ($)')
plt.legend()
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Trade summary
total_trades = len(trade_log[trade_log['Shares'] > 0])  # Only count trades with shares > 0
winning_trades = trade_log[trade_log['Profit/Loss'] > 0]
losing_trades = trade_log[trade_log['Profit/Loss'] < 0]
print(f"Total Trades: {total_trades}")
print(f"Winning Trades: {len(winning_trades)}")
print(f"Losing Trades: {len(losing_trades)}")

# Plotting Profit/Loss of each trade
plt.figure(figsize=(12, 6))
trade_log['Profit/Loss'].plot(kind='bar', color=['green' if x > 0 else 'red' for x in trade_log['Profit/Loss']])
plt.title('Profit/Loss of Each Trade')
plt.ylabel('Profit/Loss ($)')
plt.grid(True, linestyle='--', alpha=0.6)
plt.show()

# Display the trade log with Profit/Loss
print(trade_log[['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss', 'Strategy']])

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

# Initialize values
initial_balance = 500  # Starting balance
balance = initial_balance
balance_over_time = []
holding_periods = []  # To track when we were holding stock

# Track open trades for each strategy
open_trades = {'MACD Crossover': False, 'MACD Histogram': False, 'Bollinger Bands': False, 'Golden Cross/Death Cross': False}
shares_held = {'MACD Crossover': 0, 'MACD Histogram': 0, 'Bollinger Bands': 0, 'Golden Cross/Death Cross': 0}

# Trade log to track each trade
trade_log = pd.DataFrame(columns=['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss', 'Strategy'])

# Simulate the paper trading for each strategy
for i, row in sp500.iterrows():
    close_price = row['Close']
    trade_date = row.name
    amount_to_invest = 1 * balance  # Recalculate 100% of the balance each time

    ### MACD Crossover Strategy ###
    if row['MACD'] > row['Signal_Line'] and not open_trades['MACD Crossover']:  # Buy signal
        shares_to_buy = amount_to_invest // close_price
        if shares_to_buy > 0:
            open_trades['MACD Crossover'] = True
            shares_held['MACD Crossover'] = shares_to_buy
            balance -= shares_to_buy * close_price
            holding_periods.append([trade_date, None])  # Start of holding period

            # Log the buy trade
            trade_log = pd.concat([trade_log, pd.DataFrame({
                'Date': [trade_date],
                'Action': ['Buy'],
                'Shares': [shares_to_buy],
                'Price': [close_price],
                'Balance': [balance],
                'Portfolio Value': [balance + (shares_to_buy * close_price)],
                'Profit/Loss': [0],  # No profit/loss for a buy
                'Strategy': ['MACD Crossover']
            })], ignore_index=True)

    elif row['MACD'] < row['Signal_Line'] and row['RSI'] > 70 and open_trades['MACD Crossover']:  # Sell signal
        sell_value = shares_held['MACD Crossover'] * close_price
        balance += sell_value

        # Calculate the profit/loss
        buy_price = trade_log.loc[trade_log['Strategy'] == 'MACD Crossover', 'Price'].iloc[-1]
        profit_loss = (close_price - buy_price) * shares_held['MACD Crossover']

        # Log the sell trade
        trade_log = pd.concat([trade_log, pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Sell'],
            'Shares': [shares_held['MACD Crossover']],
            'Price': [close_price],
            'Balance': [balance],
            'Portfolio Value': [balance],
            'Profit/Loss': [profit_loss],
            'Strategy': ['MACD Crossover']
        })], ignore_index=True)

        open_trades['MACD Crossover'] = False  # Reset to allow future trades
        shares_held['MACD Crossover'] = 0  # Reset shares after selling
        holding_periods[-1][1] = trade_date  # End of holding period

    ### Bollinger Bands Strategy ###
    if close_price < row['Bollinger_Lower'] and not open_trades['Bollinger Bands']:  # Buy signal
        shares_to_buy = amount_to_invest // close_price
        if shares_to_buy > 0:
            open_trades['Bollinger Bands'] = True
            shares_held['Bollinger Bands'] = shares_to_buy
            balance -= shares_to_buy * close_price
            holding_periods.append([trade_date, None])  # Start of holding period

            # Log the buy trade
            trade_log = pd.concat([trade_log, pd.DataFrame({
                'Date': [trade_date],
                'Action': ['Buy'],
                'Shares': [shares_to_buy],
                'Price': [close_price],
                'Balance': [balance],
                'Portfolio Value': [balance + (shares_to_buy * close_price)],
                'Profit/Loss': [0],  # No profit/loss for a buy
                'Strategy': ['Bollinger Bands']
            })], ignore_index=True)

    elif close_price > row['Bollinger_Upper'] and open_trades['Bollinger Bands']:  # Sell signal
        sell_value = shares_held['Bollinger Bands'] * close_price
        balance += sell_value

        # Calculate the profit/loss
        buy_price = trade_log.loc[trade_log['Strategy'] == 'Bollinger Bands', 'Price'].iloc[-1]
        profit_loss = (close_price - buy_price) * shares_held['Bollinger Bands']

        # Log the sell trade
        trade_log = pd.concat([trade_log, pd.DataFrame({
            'Date': [trade_date],
            'Action': ['Sell'],
            'Shares': [shares_held['Bollinger Bands']],
            'Price': [close_price],
            'Balance': [balance],
            'Portfolio Value': [balance],
            'Profit/Loss': [profit_loss],
            'Strategy': ['Bollinger Bands']
        })], ignore_index=True)

        open_trades['Bollinger Bands'] = False  # Reset to allow future trades
        shares_held['Bollinger Bands'] = 0  # Reset shares after selling
        holding_periods[-1][1] = trade_date  # End of holding period

    # Record portfolio value (balance + value of held shares)
    portfolio_value = balance + (shares_held['MACD Crossover'] * close_price) + (shares_held['Bollinger Bands'] * close_price)
    balance_over_time.append(portfolio_value)

# Final balance after all trades
final_balance = balance + (shares_held['MACD Crossover'] * sp500['Close'].iloc[-1]) + (shares_held['Bollinger Bands'] * sp500['Close'].iloc[-1])
profit = final_balance - initial_balance

# Convert balance over time to pandas series for plotting
balance_over_time = pd.Series(balance_over_time, index=sp500.index[:len(balance_over_time)])

# Set up the dashboard layout using GridSpec
fig = plt.figure(figsize=(10, 7))
fig.patch.set_facecolor('black')  # Set figure background to black
gs = GridSpec(3, 3, figure=fig)

# Plot 1: Portfolio Value vs S&P 500 Close Price with shading for holding periods
ax1 = fig.add_subplot(gs[0, :])
ax1.plot(sp500.index, balance_over_time, label='Portfolio Value', color='cyan')
ax1.plot(sp500.index, sp500['Close'], label='S&P 500 Close Price', color='magenta', alpha=0.5)
ax1.set_title('Portfolio Value vs S&P 500 Close Price', color='white')
ax1.set_xlabel('Date', color='white')
ax1.set_ylabel('Value ($)', color='white')
ax1.legend()
ax1.grid(True, linestyle='--', alpha=0.3)
ax1.set_facecolor('black')  # Set axes background to black
ax1.tick_params(colors='white')  # Set tick colors to white

# Add shading for holding periods
for period in holding_periods:
    if period[1]:  # Ensure the holding period has an end date
        ax1.axvspan(period[0], period[1], color='orange', alpha=0.2)

# Plot 2: Profit/Loss of each trade without x-axis labels
ax2 = fig.add_subplot(gs[1, :2])
trade_log['Profit/Loss'].plot(kind='bar', ax=ax2, color=['green' if x > 0 else 'red' for x in trade_log['Profit/Loss']])
ax2.set_title('Profit/Loss of Each Trade', color='white')
ax2.set_ylabel('Profit/Loss ($)', color='white')
ax2.grid(True, linestyle='--', alpha=0.3)
ax2.set_facecolor('black')  # Set axes background to black
ax2.set_xticks([])
ax2.tick_params(colors='white')  # Set tick colors to white

# Plot 3: Trade summary table with directionality percentage (Moved table to a higher position)
ax3 = fig.add_subplot(gs[1:, 2])
ax3.axis('off')

# Create a trade summary table (Rounded Win/Loss Ratio as percentage, moved table higher)
win_trades = len(trade_log[trade_log['Profit/Loss'] > 0])
loss_trades = len(trade_log[trade_log['Profit/Loss'] < 0])

summary_data = pd.DataFrame({
    'Winning Trades': [win_trades],
    'Losing Trades': [loss_trades],
})

# Increase column width to avoid text truncation
col_widths = [0.35, 0.35]

# Display the summary table
table = ax3.table(cellText=summary_data.values, colLabels=summary_data.columns, cellLoc='center', loc='upper center', colWidths=col_widths)

# Set table background color to black and text to white for visibility
table.auto_set_font_size(False)
table.set_fontsize(10)
table.scale(1.5, 1.5)

# Set the background and font color for the table cells
for key, cell in table.get_celld().items():
    cell.set_edgecolor('white')  # White borders
    cell.set_text_props(color='white')  # White text
    cell.set_facecolor('black')  # Black background for table cells

# Add space at the top and move everything down
plt.tight_layout()

# Adjust the top to move everything down and add space at the top
plt.subplots_adjust(top=0.85, bottom=0.1, hspace=0.5)

# Show the dashboard
plt.show()

# Display the trade log with Profit/Loss
print(trade_log[['Date', 'Action', 'Shares', 'Price', 'Balance', 'Portfolio Value', 'Profit/Loss', 'Strategy']])