src/streamlit_app.py

import os
import sys
import streamlit as st
import pandas as pd
import numpy as np
from io import BytesIO
import uuid
from tvDatafeed import TvDatafeed, Interval

from huggingface_hub import snapshot_download

# Download files from the private space
private_repo = "kishan-1721/my_private_app"  # Replace with your private space's repo ID
cache_dir = "/data/private_space_cache"  # Updated to use writable /data directory
snapshot_download(
    repo_id=private_repo,
    repo_type="space",
    local_dir=cache_dir,
    token=os.getenv("HF_TOKEN")  # Assumes HF_TOKEN is set as a secret
)

# Add the downloaded files to the Python path
sys.path.append(cache_dir)

# --- Streamlit Page Configuration ---
st.set_page_config(page_title="Stock Market Analyzer", layout="wide")

# --- Main Application ---
def main():
    st.title("Stock Market Analyzer")

    with st.container():
        col1, col2, col3, col4, col5, col6 = st.columns(6)
        with col1:
            global sideways_threshold
            sideways_threshold = st.slider("Sideways Threshold", min_value=0.0, max_value=2.0, value=0.0, step=0.01, format="%.2f") / 100
        with col2:
            global buffer
            buffer = st.slider("Buffer", min_value=0.0, max_value=2.0, value=0.0, step=0.01, format="%.2f") / 100
        with col3:
            global intra_sl_value
            intra_sl_value = st.slider("Intra SL Value", min_value=0.0, max_value=10.0, value=1.5, step=0.1, format="%.1f") / 100
        with col4:
            global target_sl
            target_sl = st.slider("Target SL Value", min_value=0.0, max_value=15.0, value=0.0, step=0.1, format="%.1f") / 100
        with col5:
            global trail_offset
            trail_offset = st.slider("Trailing SL %", min_value=0.0, max_value=10.0, value=3.0, step=0.1, format="%.1f") / 100
        with col6:
            global max_loss_sl
            max_loss_sl = st.slider("MaxLoss SL Value", min_value=0.0, max_value=10.0, value=3.0, step=0.1, format="%.1f") / 100
            
    with st.container():
        col1, col2, col4, col3  = st.columns([1,1,1,2])

        with col1:
            Trailing_Value = st.radio(
                "Set your Trailing Value ?",
                ["Close", "High - Low"],
                index=1
            )

            Exchange = st.radio(
                "Select your Exchange ?",
                ["Indian", "Crypto"],
                index=0
            )

        with col2:
            global brokerages
            brokerages = st.number_input(label="Brokerages",step=0.01,value=0.2644 ,format="%.4f")

            global interest_rate
            interest_rate = st.number_input(label="Funding Cost Per Day",step=0.01,value=0.04 ,format="%.4f")

            if intra_sl_value <= 0.0:
                st.text("IntraBar is Set to Previous Top - Bottom")
            if target_sl <= 0.0:
                st.text("No Target is Set")
            if trail_offset <= 0.0:
                st.text("No Trailing Stop-loss")

        with col4:
            global MTF_Exposure
            MTF_Exposure = st.slider("MTF Exposure", min_value=2.00, max_value=8.00, value=3.00, step=0.1, format="%.2f")

            selected_script  = st.radio(
                "Select Your Script",
                ["Old", "New Maxloss"],
                index=0
            )

        with col3:
            # File uploader

            if Exchange == 'Indian':
                symbol = ['NIFTY', 'BANKNIFTY', 'FINNIFTY', 'NIFTYIT', 'NIFTYFMCG', 'NIFTYMETAL', 'NIFTYPSU', 'NIFTYAUTO', 'NIFTYMEDIA', 'NIFTYPVTBANK', 'NIFTYREALTY', 'NIFTYCONSUMER', 'NIFTYENERGY', 
                          'NIFTYHEALTHCARE', 'NIFTYINFRA', 'NIFTYPHARMA', 'RELIANCE', 'TATAMOTORS', 'HDFCBANK', 'ICICIBANK', 'INFY', 'HINDUNILVR', 'LT', 'TCS', 'HDFC', 'KOTAKBANK', 'AXISBANK', 'ITC', 'SBIN', 'MARUTI', 'BAJFINANCE']
                exchange_list = ['NSE', 'BSE', 'MCX', 'NFO', 'CDS']
            else:
                symbol = ['ETHUSDT', 'BTCUSDT', 'BNBUSDT', 'XRPUSDT', 'SOLUSDT', 'DOGEUSDT', 'ADAUSDT', 'MATICUSDT', 'DOTUSDT', 'TRXUSDT']
                exchange_list = ['BINANCE', 'BITFINEX', 'COINBASE', 'BITSTAMP', 'OKEX', 'BYBIT', 'GEMINI']

            ## Add search functionality in selectbox
            # symbol = st.selectbox("Select Symbol", symbol, index=0, key="symbol_select")
            symbol = st.selectbox("Select Symbol", symbol, index=0, key="symbol_select", help="Search for a symbol by typing in the box")
            symbol_exchange = st.selectbox("Select Exchange", exchange_list, index=0, key="exchange_select", help="Search for an exchange by typing in the box")


            # symbol = st.selectbox("Select Symbol", symbol, index=0)
            # symbol_exchange = st.selectbox("Select Exchange", exchange_list, index=0)
            
            # uploaded_file = st.file_uploader("Upload your CSV file", type=["csv"])

    if selected_script == "Old":
        from main4 import get_buy_signal, parse_date, get_sell_signal, year_wise_analysis, calculate_yearly_returns, calculate_mtf_returns, crypto_year_wise_analysis, crypto_calculate_mtf_returns, crypto_calculate_yearly_returns, find_sequences, generate_trade_signals, data_collection
    else:
        from main6 import get_buy_signal, parse_date, get_sell_signal, year_wise_analysis, calculate_yearly_returns, calculate_mtf_returns, crypto_year_wise_analysis, crypto_calculate_mtf_returns, crypto_calculate_yearly_returns, find_sequences, generate_trade_signals, data_collection
    

    if st.button("Start Analysis"):
        HISTORICAL_DATA = data_collection(symbol = symbol, exchange = symbol_exchange)



        # st.divider()
        if HISTORICAL_DATA is not None:
            df = HISTORICAL_DATA.copy()
            try:
                df = df[['Date','Open','High', 'Low', 'Close']]
            except:
                df = df[['Date','Open','High', 'Low', 'Price']]

        # if st.button("Start Analysis"):
            # Data preprocessing
            df.columns = df.columns.str.strip()
            df['Date'] = parse_date(df['Date'])
            df.sort_values('Date', inplace=True)

            if 'Price' in df.columns:
                df = df.rename(columns={'Price': 'Close'})
            df['%Change'] = df['Close'].pct_change().fillna(0) * 100
            df["Direction"] = df["%Change"].apply(lambda x: "📈" if x > 0 else "📉")
            df['Side Ways'] = df['%Change'].apply(lambda x: abs(x / 100) < sideways_threshold)

            # Generate signals and trades
            # result = generate_trade_signals(df, trail_offset, target_sl, Trailing_Value)
            
            if selected_script == "Old":
                result = generate_trade_signals(df, trail_offset, target_sl, Trailing_Value, buffer, intra_sl_value)
            else:    
                result = generate_trade_signals(df, trail_offset, target_sl, Trailing_Value, buffer, intra_sl_value, max_loss_sl)
                
            final_df = result[1]
            final_df['Gap Loss 2%'] = final_df.apply(lambda x: True if x['Gap_UP_Down Trade'] == True and x['Profit %'] < -2 else False, axis=1)
            final_df['Gap Exit'] = np.where(final_df['Gap_UP_Down Trade'].shift(-1).eq(True), True, False)
            final_df['Gap Exit Loss % 2'] = np.where(final_df['Gap_UP_Down Trade'].shift(-1).eq(True) & (final_df['Profit %'] < -2), True, False)

            col1, col2 = st.columns(2)

            # with col1:
            #     st.subheader("📶 Processed Signal Data", divider=True)
            #     st.dataframe(final_df)

            df = df.assign(Year=df['Date'].dt.year)
            final_df = final_df.assign(Year=final_df['Entry Date'].dt.year)

            if Exchange == 'Indian':

    ################################################### Performing Analysis ###################################################

                system_returns_no_compound, system_yearly_no_compound = calculate_yearly_returns(df,final_df, False, brokerages)

                system_returns_with_compound, system_yearly_with_compound = calculate_yearly_returns(df,final_df, True, brokerages)

                system_mtf_no_compound, system_mtf_yearly_no_compound = calculate_mtf_returns(df,final_df, MTF_Exposure, False, brokerages)
                            
                system_mtf_with_compound, system_mtf_yearly_with_compound = calculate_mtf_returns(df,final_df, MTF_Exposure, True, brokerages)
                
    ################################################### BUY Trade Performing Analysis ###################################################

                buy_trades_df = final_df[final_df['Trade Type'] == 'BUY']

                buy_trades_no_compound, buy_trades_yearly_no_compound = calculate_yearly_returns(df,buy_trades_df, False, brokerages)

                buy_trades_compound, buy_trades_yearly_compound = calculate_yearly_returns(df,buy_trades_df, True, brokerages)

                buy_trades_mtf_no_compound, buy_trades_mtf_yearly_no_compound = calculate_mtf_returns(df,buy_trades_df, MTF_Exposure, False, brokerages)

                buy_trades_mtf_returns_compound, buy_trades_mtf_yearly_compound = calculate_mtf_returns(df,buy_trades_df, MTF_Exposure, True, brokerages)

            else:
    ################################################### Crypto Performing Analysis ###################################################

    ################################################### Performing Analysis ###################################################

                system_returns_no_compound, system_yearly_no_compound = crypto_calculate_yearly_returns(df,final_df, False, brokerages)

                system_returns_with_compound, system_yearly_with_compound = crypto_calculate_yearly_returns(df,final_df, True, brokerages)

                system_mtf_no_compound, system_mtf_yearly_no_compound = crypto_calculate_mtf_returns(df,final_df, MTF_Exposure, False, brokerages, interest_rate)
                            
                system_mtf_with_compound, system_mtf_yearly_with_compound = crypto_calculate_mtf_returns(df,final_df, MTF_Exposure, True, brokerages, interest_rate)
                
    ################################################### BUY Trade Performing Analysis ###################################################

                buy_trades_df = final_df[final_df['Trade Type'] == 'BUY']

                buy_trades_no_compound, buy_trades_yearly_no_compound = crypto_calculate_yearly_returns(df,buy_trades_df, False, brokerages)

                buy_trades_compound, buy_trades_yearly_compound = crypto_calculate_yearly_returns(df,buy_trades_df, True, brokerages)

                buy_trades_mtf_no_compound, buy_trades_mtf_yearly_no_compound = crypto_calculate_mtf_returns(df,buy_trades_df, MTF_Exposure, False, brokerages, interest_rate)

                buy_trades_mtf_returns_compound, buy_trades_mtf_yearly_compound = crypto_calculate_mtf_returns(df,buy_trades_df, MTF_Exposure, True, brokerages, interest_rate)

            # system_yearly_analysis = year_wise_analysis(df, system_returns_no_compound)
            # System_Gain_Com = year_wise_analysis(df, system_returns_with_compound)
            # year_analysis_ = year_wise_analysis(df, system_mtf_with_compound)

            System_Gain_Com = system_mtf_yearly_no_compound
            # year_analysis_ = system_mtf_yearly_with_compound

            initial_investment_amount = 100000

            with col1:
                st.subheader("📆 Year-Wise Performance", divider=True)
                st.dataframe(system_yearly_no_compound)

            with col2:
                st.subheader("📶 Compounding Year-Wise Performance", divider=True)
                st.dataframe(System_Gain_Com)


            pcol1, pcol2, pcol3 = st.columns(3)
            
            with pcol1:
                st.subheader("📊 Performance Overview", divider=True)
                
                container = st.container(border=True)
                container.text(f"Average Trades : {round(system_yearly_no_compound['Total_Trades'].mean(), 0)}")
                container.text(f"Average BUY Trades : {round(system_yearly_no_compound['Total BUY Trades'].mean(), 0)}")
                container.text(f"Average SELL Trades : {round(system_yearly_no_compound['Total SELL Trades'].mean(), 0)}")

                container = st.container(border=True)
                container.text(f"Start Price {system_yearly_no_compound['Start_Price'].iloc[0]}, End Price : {system_yearly_no_compound['End_Price'].iloc[-1]}")
                container.text(f"Average Index Gain %: {round(system_yearly_no_compound['Index Gain'].sum() / len(system_yearly_no_compound), 2)}")
                container.text(f"Index CAGR = {round(((system_yearly_no_compound['End_Price'].iloc[-1] / system_yearly_no_compound['Start_Price'].iloc[0]) ** (1 / len(system_yearly_no_compound)) - 1) * 100, 2) } ")

                # container.text(f"Average System Gain %: {round(system_yearly_no_compound['System Gain'].sum() / len(system_yearly_no_compound), 2)}")
                # container.text(f"Difference: {round(system_yearly_no_compound['Difference'].sum() / len(system_yearly_no_compound) , 2) }")

            with pcol2:
                st.subheader("📊 Trade Overview", divider=True)

                container = st.container(border=True)               
                container.text(f"Total Years : {len(system_yearly_no_compound)}")
                container.text(f"Total Trades: {len(final_df)}")
                container.text(f"Profitable Trades {round(len(final_df[final_df['Profit'] > 0]))}")
                container.text(f"Total Target Hit: {len(final_df[final_df['Exit Condition'] == 'Target Hit'])}")
                container.text(f"Total Trailing Hit: {len(final_df[final_df['Exit Condition'] == 'Trailing Hit'])}")
                container.text(f"Total IntraBar Hit: {len(final_df[final_df['Exit Condition'] == 'IntraBar Hit'])}")
                container.text(f"Total MaxLoss Hit: {len(final_df[final_df['Exit Condition'] == f'MaxLoss {max_loss_sl*100}% Hit'])}")
                container.text(f"High - Low Average: {round(final_df['change %'].mean(), 2)}")
                # container.text(f"High - Low Average Number new: {round(np.percentile(final_df['change %'], 60), 2)}")
                container.text(f"% Winning Ratio {round((len(final_df[final_df['Profit'] > 0]) / len(final_df)) * 100, 2)} %")

            with pcol3:
                st.subheader("📊 Gap Up & Down Overview", divider=True)

                container = st.container(border=True)               
                container.text(f"Total Gap_UP_Down Trades: {final_df['Gap_UP_Down Trade'].sum()}")
                container.text(f"Total Gap_UP_Down Exit Trades: {final_df['Gap Exit'].sum()}")
                container.text(f"Loss More than 2 % in Gap_UP_Down Trades: {final_df['Gap Loss 2%'].sum()}")
                container.text(f"Loss More than 2 % in Gap_UP_Down Exit Trades: {final_df['Gap Exit Loss % 2'].sum()}")


                ################################## Risk Reward Ratio ##################################
                container = st.container(border=True)               
                
                p_trades = len(final_df[final_df['Profit'] > 0])
                N_trades = len(final_df[final_df['Profit'] < 0])

                p_profit_ = final_df[final_df['Profit'] > 0]['Profit'].sum()
                N_profit_ = final_df[final_df['Profit'] < 0]['Profit'].sum()

                p_profit_avg = final_df[final_df['Profit'] > 0]['Profit %'].mean()
                N_profit_avg = final_df[final_df['Profit'] < 0]['Profit %'].mean()
                
                # container.text(f" (p_profit = {p_profit_} / p_trades = {p_trades}) / (N_profit_ = {N_profit_} / N_trades = {N_trades})")

                ratio = abs((p_profit_ / p_trades) / ( N_profit_ / N_trades))

                container.text(f"% Risk Reward Ratio: {round(ratio, 3 )} %")
                container.text(f"% Profit Avg: {round(p_profit_avg, 4 )} %")
                container.text(f"% Loss Avg: {round(N_profit_avg, 4 )} ")

                if Exchange != 'Indian':
                    container.text(f"Max Holding Days: {System_Gain_Com['HOLDING DAYS'].max()}")
                

            st.divider()
################################################### Performance Analysis ###################################################

            pcol1, pcol2, pcol3 = st.columns(3)

            with pcol1:
                st.subheader("📈 System Performance", divider=True)

                total_profit_ = round(system_yearly_no_compound['Final Profit After All'].sum(), 2)
                total_profit_AVG = round(system_yearly_no_compound['System Gain'].sum() / len(system_yearly_no_compound), 2)

                buy_profit = round(buy_trades_yearly_no_compound['Final Profit After All'].sum(), 2)
                buy_profit_AVG = round(buy_trades_yearly_no_compound['System Gain'].sum() / len(buy_trades_yearly_no_compound), 2)

                sell_profit = round(total_profit_ - buy_profit, 2)
                sell_profit_avg = round(total_profit_AVG - buy_profit_AVG, 2)

                container = st.container(border=True)
                container.write(f"**Total Profit : {total_profit_} (AVG : {total_profit_AVG} %)**")
                container.write(f"**Buy Profit : {buy_profit} (AVG : {buy_profit_AVG} %)**")
                container.write(f"**SELL Profit : {sell_profit} (AVG : {sell_profit_avg} %)**")
                container.text(f"Total Years : {len(system_yearly_no_compound)}")

                # container.write(f"**Total BUY Profit : {round(system_yearly_no_compound['BUY_Profit'].sum(), 2)} ({round((system_yearly_no_compound['BUY_Profit'].sum() * 100)/system_yearly_no_compound['Profit'].sum(), 2)} %) (AVG : {round(system_yearly_no_compound['BUY_Gain'].mean(), 2)} %)**")
                # container.write(f"**Total SELL Profit : {round(system_yearly_no_compound['SELL_Profit'].sum(), 2)} ({round((system_yearly_no_compound['SELL_Profit'].sum() * 100)/system_yearly_no_compound['Profit'].sum(), 2)} %)**")
                
                container.markdown("---") 
                ten_years = system_yearly_no_compound.tail(10)
                container.write(f"**Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
                # container.text(f"Last 10 Years Only BUY AVG % : {round(ten_years['BUY_Gain'].mean(), 2)}")

                ten_years = buy_trades_yearly_no_compound.tail(10)
                container.write(f"**Buy System Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
                
                container.markdown("---") 
                five_years = system_yearly_no_compound.tail(5)
                container.write(f"**Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                five_years = buy_trades_yearly_no_compound.tail(5)
                container.write(f"**Buy System Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
                
                container.markdown("---") 
                three_years = system_yearly_no_compound.tail(3)
                container.write(f"**Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                three_years = buy_trades_yearly_no_compound.tail(3)
                container.write(f"**Buy System Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")

                container.markdown("---") 
                two_years = system_yearly_no_compound.tail(2)
                container.write(f"**Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                two_years = buy_trades_yearly_no_compound.tail(2)
                container.write(f"**Buy System Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")

                container.markdown("---") 
                one_years = system_yearly_no_compound.tail(1)
                container.write(f"**Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                one_years = buy_trades_yearly_no_compound.tail(1)
                container.write(f"**Buy System Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")

            with pcol2:
                st.subheader("📈 Compounding Performance", divider=True)

                compund_system_cagr = round((((((system_yearly_with_compound['Final Profit After All'].sum()) + 100000) / 100000 ) ** (1 / len(system_yearly_with_compound))) -1 ) * 100 , 2)
                buy_compund_system_cagr = round((((((buy_trades_yearly_compound['Final Profit After All'].sum()) + 100000) / 100000) ** (1 / len(buy_trades_yearly_compound))) -1 ) * 100 , 2)

                container = st.container(border=True)
                container.write(f"**Total Profit : {round(system_yearly_with_compound['Final Profit After All'].sum(), 2)} (AVG : {round(system_yearly_with_compound['System Gain'].sum() / len(system_yearly_with_compound), 2)} %) (C:{compund_system_cagr} %)**")
                container.write(f"**Buy Profit : {round(buy_trades_yearly_compound['Final Profit After All'].sum(), 2)} (AVG : {round(buy_trades_yearly_compound['System Gain'].sum() / len(buy_trades_yearly_compound), 2)} %) (C:{buy_compund_system_cagr} %)**")
                container.write(f"Initial Investment : {initial_investment_amount}")

                # container.write(f"**Total BUY Profit : {round(system_yearly_with_compound['BUY_Profit'].sum(), 2)} ({round((system_yearly_with_compound['BUY_Profit'].sum() * 100)/system_yearly_with_compound['Profit'].sum(), 2)} %) (AVG : {round(system_yearly_with_compound['BUY_Gain'].mean(), 2)} %)**")
                # container.write(f"**Total SELL Profit : {round(system_yearly_with_compound['SELL_Profit'].sum(), 2)} ({round((system_yearly_with_compound['SELL_Profit'].sum() * 100)/system_yearly_with_compound['Profit'].sum(), 2)} %)**")
                
                container.markdown("---") 
                ten_years = system_yearly_with_compound.tail(10)
                container.write(f"**Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
                # container.text(f"Last 10 Years Only BUY AVG % : {round(ten_years['BUY_Gain'].mean(), 2)}")

                ten_years = buy_trades_yearly_compound.tail(10)
                container.write(f"**Buy System Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
                
                container.markdown("---") 
                five_years = system_yearly_with_compound.tail(5)
                container.write(f"**Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
                
                five_years = buy_trades_yearly_compound.tail(5)
                container.write(f"**Buy System Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")

                container.markdown("---") 
                three_years = system_yearly_with_compound.tail(3)
                container.write(f"**Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
                
                three_years = buy_trades_yearly_compound.tail(3)
                container.write(f"**Buy System Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")

                container.markdown("---") 
                two_years = system_yearly_with_compound.tail(2)
                container.write(f"**Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
                
                two_years = buy_trades_yearly_compound.tail(2)
                container.write(f"**Buy System Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")

                container.markdown("---") 
                one_years = system_yearly_with_compound.tail(1)
                container.write(f"**Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")
                
                one_years = buy_trades_yearly_compound.tail(1)
                container.write(f"**Buy System Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")

            with pcol3:
                st.subheader("📈 MTF Compounding Gain", divider=True)

                mtf_investment = initial_investment_amount / MTF_Exposure 

                compund_system_cagr = round((((((system_mtf_yearly_with_compound['Final Profit After All'].sum()) + mtf_investment) / mtf_investment) ** (1 / len(system_mtf_yearly_with_compound))) -1 ) * 100 , 2)
                buy_compund_system_cagr = round((((((buy_trades_mtf_yearly_compound['Final Profit After All'].sum()) + mtf_investment) / mtf_investment) ** (1 / len(buy_trades_mtf_yearly_compound))) -1 ) * 100 , 2)

                container = st.container(border=True)
                container.write(f"**Total Profit : {round(system_mtf_yearly_with_compound['Final Profit After All'].sum(), 2)} (AVG : {round(system_mtf_yearly_with_compound['System Gain'].sum() / len(system_mtf_yearly_with_compound), 2)} %) (C:{compund_system_cagr} %)**")
                container.write(f"**Buy Profit : {round(buy_trades_mtf_yearly_compound['Final Profit After All'].sum(), 2)} (AVG : {round(buy_trades_mtf_yearly_compound['System Gain'].sum() / len(buy_trades_mtf_yearly_compound), 2)} %) (C:{buy_compund_system_cagr} %)**")
                container.write(f"Initial Investment : {mtf_investment}")

                # container.write(f"**Total BUY Profit : {round(system_mtf_yearly_with_compound['BUY_Profit'].sum(), 2)} ({round((system_mtf_yearly_with_compound['BUY_Profit'].sum() * 100)/system_mtf_yearly_with_compound['Profit'].sum(), 2)} %) (AVG : {round(system_mtf_yearly_with_compound['BUY_Gain'].mean(), 2)} %)**")
                # container.write(f"**Total SELL Profit : {round(system_mtf_yearly_with_compound['SELL_Profit'].sum(), 2)} ({round((system_mtf_yearly_with_compound['SELL_Profit'].sum() * 100)/system_mtf_yearly_with_compound['Profit'].sum(), 2)} %)**")
                
                container.markdown("---") 
                ten_years = system_mtf_yearly_with_compound.tail(10)
                container.write(f"**Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
                # container.text(f"Last 10 Years Only BUY AVG % : {round(ten_years['BUY_Gain'].mean(), 2)}")

                ten_years = buy_trades_mtf_yearly_compound.tail(10)
                container.write(f"**Buy System Last 10 Years AVG %: {round(ten_years['System Gain'].sum() / len(ten_years), 2)}**")
                
                container.markdown("---") 
                five_years = system_mtf_yearly_with_compound.tail(5)
                container.write(f"**Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                five_years = buy_trades_mtf_yearly_compound.tail(5)
                container.write(f"**Buy System Last 5 Years AVG %: {round(five_years['System Gain'].sum() / len(five_years), 2)}**")

                container.markdown("---") 
                three_years = system_mtf_yearly_with_compound.tail(3)
                container.write(f"**Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                three_years = buy_trades_mtf_yearly_compound.tail(3)
                container.write(f"**Buy System Last 3 Years AVG %: {round(three_years['System Gain'].sum() / len(three_years), 2)}**")

                container.markdown("---") 
                two_years = system_mtf_yearly_with_compound.tail(2)
                container.write(f"**Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                two_years = buy_trades_mtf_yearly_compound.tail(2)
                container.write(f"**Buy System Last 2 Years AVG %: {round(two_years['System Gain'].sum() / len(two_years), 2)}**")
           
                container.markdown("---") 
                one_years = system_mtf_yearly_with_compound.tail(1)
                container.write(f"**Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
                # container.text(f"Last 5 Years Only BUY AVG % : {round(five_years['BUY_Gain'].mean(), 2)}")

                one_years = buy_trades_mtf_yearly_compound.tail(1)
                container.write(f"**Buy System Last 1 Years AVG %: {round(one_years['System Gain'].sum() / len(one_years), 2)}**")
           
            temp = final_df[['Entry Date', 'Trade Type', 'Gap_UP_Down Trade', 'GAP_P', 'Entry Price', 'Exit Date', 'Exit Condition', 'Exit Price', 'Profit', 'Profit %', 'Gap Loss 2%','Year']]
            temp.rename(columns={'Trade Type' : 'Trade', 'Gap_UP_Down Trade' : 'GAP', 'Entry Price' : 'Entry', 'Exit Price' : 'Exit', 'Gap Loss 2%' : 'Gap Loss %'}, inplace = True)
            
            # Filter out rows where '% Profit' is NaN and sort by 'Entry Date'
            def max_Profit_loss(final_df):
                filtered_df = final_df[final_df['Profit %'].notna()].sort_values('Entry Date')

                # Define conditions for profit and loss sequences
                profit_condition = lambda row: row['Profit %'] >= 0
                loss_condition = lambda row: row['Profit %'] <= 0

                # Find profit and loss sequences
                profit_sequences = find_sequences(filtered_df, profit_condition)
                loss_sequences = find_sequences(filtered_df, loss_condition)

                # Convert sequences to DataFrames
                profit_df = pd.DataFrame(profit_sequences)
                loss_df = pd.DataFrame(loss_sequences)

                # Get top 20 sequences
                # Top 20 profit sequences (highest total % profit)
                top_profit_df = profit_df.sort_values('Total %', ascending=False).head(20)
                # Top 20 loss sequences (most negative total % loss)
                top_loss_df = loss_df.sort_values('Total %', ascending=True).head(20)

                # Add 'Type' column to distinguish between profit and loss
                top_profit_df['Type'] = 'Profit'
                top_loss_df['Type'] = 'Loss'

                top_profit_df.reset_index(drop=True, inplace=True)
                top_loss_df.reset_index(drop=True, inplace=True)

                data = {
                    'Year_L': top_loss_df['Start Date'].apply(lambda x: x.year),
                    # 'End Date_Loss': top_loss_df['End Date'],
                    '%_Loss': top_loss_df['Total %'],
                    
                    'Year_P': top_profit_df['Start Date'].apply(lambda x: x.year),
                    # 'End Date_Profit': top_profit_df['End Date'],
                    '%_Profit': top_profit_df['Total %']
                }
                return pd.DataFrame(data)
                
            st.divider()
            
            st.subheader("Detail Analysis of Maximum Profit 📈 and Loss 📉", divider=True)
            pcol1, pcol2, pcol3 = st.columns([1,1,2])

            with pcol1:
                st.text("General Analysis")
                profit_loss_all = max_Profit_loss(final_df)
                st.dataframe(profit_loss_all)

            with pcol2:
                st.text("Only in BUY Trades")
                profit_loss_all_BUY = max_Profit_loss(buy_trades_df)
                st.dataframe(profit_loss_all_BUY)
            
            with pcol3:
                st.text("Gap Up & Down Loss 📉")
                st.dataframe(final_df[final_df['Gap Exit Loss % 2'] == True].reset_index())

            # Save to Excel
            excel_buffer = BytesIO()
            with pd.ExcelWriter(excel_buffer, engine='openpyxl') as writer:
                final_df.to_excel(writer, sheet_name='Trades Analysis', index=False)
                # temp.to_excel(writer, sheet_name='Full Analysis', index=False)
                system_returns_no_compound.to_excel(writer, sheet_name='System Analysis', index=False)
                system_yearly_no_compound.to_excel(writer, sheet_name='System Yearly', index=False)

                profit_loss_all.to_excel(writer, sheet_name='Profit-Loss Analysis', index=False)

                system_returns_with_compound.to_excel(writer, sheet_name='System Compounding', index=False)
                system_yearly_with_compound.to_excel(writer, sheet_name='System Compounding Yearly', index=False)

                system_mtf_no_compound.to_excel(writer, sheet_name='MTF System Analysis', index=False)
                system_mtf_yearly_no_compound.to_excel(writer, sheet_name='MTF System Yearly', index=False)

                system_mtf_with_compound.to_excel(writer, sheet_name='CMP MTF System', index=False)
                system_mtf_yearly_with_compound.to_excel(writer, sheet_name='CMP MTF Yearly', index=False)

                buy_trades_no_compound.to_excel(writer, sheet_name='BUY Analysis', index=False)
                buy_trades_yearly_no_compound.to_excel(writer, sheet_name='BUY Yearly', index=False)

                buy_trades_compound.to_excel(writer, sheet_name='BUY Compound', index=False)
                buy_trades_yearly_compound.to_excel(writer, sheet_name='BUY Compound Yearly', index=False)

                buy_trades_mtf_no_compound.to_excel(writer, sheet_name='BUY MTF', index=False)
                buy_trades_mtf_yearly_no_compound.to_excel(writer, sheet_name='BUY MTF Yearly', index=False)
                
                buy_trades_mtf_returns_compound.to_excel(writer, sheet_name='BUY MTF CMP', index=False)
                buy_trades_mtf_yearly_compound.to_excel(writer, sheet_name='BUY MTF CMP Yearly', index=False)


            file_name_ = f"{symbol} Trailing {trail_offset} Target {target_sl}"

            excel_buffer.seek(0)
            st.download_button(
                label="Download Excel File",
                data=excel_buffer,
                file_name=f"Analysis of {file_name_}.xlsx",
                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
            )
            
        else:
            st.error("No historical data found for the selected symbol and exchange. Please check the inputs and try again.")

if __name__ == "__main__":
    main()