import streamlit as st
from datetime import datetime, timedelta
import yfinance as yf
import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier
import shap
import requests

# Google Apps Script Web App URL
WEB_APP_URL = "https://script.google.com/macros/s/AKfycbwzca3vtOTSITCMD4PIwkn_yDgGUbRxu5RW9bto3kStQVVbg2v7pOFNAI5wj6ywROWw/exec"

# Utility functions for persistent position storage
def save_position(position, trade_info, buy_percentage=None, sell_percentage=None):
    payload = {
        "action": "save",
        "position": position,
        "timestamp": datetime.now().isoformat(),
        "trade_info": trade_info,
        "buy_percentage": buy_percentage,
        "sell_percentage": sell_percentage
    }
    response = requests.post(WEB_APP_URL, json=payload)
    if response.status_code != 200:
        raise Exception(f"Error saving position: {response.text}")

def load_position():
    payload = {"action": "load"}
    response = requests.post(WEB_APP_URL, json=payload)
    if response.status_code == 200:
        return response.json().get("position", None), response.json().get("entry_price", None), response.json().get("buy_percentage", None), response.json().get("sell_percentage", None)
    else:
        raise Exception(f"Error loading position: {response.text}")

class DataFetcher:
    """Fetches historical financial data using yfinance."""
    def __init__(self, ticker, nb_days):
        self.ticker = ticker
        self.nb_days = nb_days
        self.data = None

    def fetch_data(self):
        """Fetches historical data for the specified ticker and number of days."""
        end_date = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
        start_date = end_date - timedelta(days=self.nb_days)
        end_date = end_date + timedelta(days=1)
        self.data = yf.download(self.ticker, start=start_date, end=end_date, interval="1h")
        return self.data

class FinancialDataProcessor:
    """Processes financial data to calculate returns, scenarios, and probabilities."""
    def __init__(self, data):
        self.data = data.copy()

    def _flatten_columns(self):
        """Flattens MultiIndex columns into a single level."""
        if isinstance(self.data.columns, pd.MultiIndex):
            self.data.columns = [f"{col[0]}_{col[1]}" if col[1] else col[0] for col in self.data.columns]

    def calculate_returns(self):
        """Calculates logarithmic returns, scenarios, and adjusted returns."""
        self._flatten_columns()

        close_column = [col for col in self.data.columns if 'Close' in col]
        if not close_column:
            raise ValueError("The 'Close' column is missing in the dataset.")
        
        self.data.rename(columns={close_column[0]: 'Close'}, inplace=True)
        self.data = self.data[self.data['Close'] > 0].copy()
        
        self.data['LogReturn'] = np.log(self.data['Close'] / self.data['Close'].shift(1))
        self.data.replace([np.inf, -np.inf], np.nan, inplace=True)
        self.data.dropna(subset=['LogReturn'], inplace=True)
        
        self.data['Scenario'] = np.where(self.data['LogReturn'] > 0, 'Buy', 'Sell')
        self.data['AdjustedLogReturn'] = np.where(
            self.data['Scenario'] == 'Sell', -self.data['LogReturn'], self.data['LogReturn']
        )
        self.data['AnnualizedReturn'] = self.data['AdjustedLogReturn'] * 252
        
        return self

    def calculate_probabilities(self):
        """Calculates Buy% and Sell% using hyperbolic tangent."""
        self.data['Buy%'] = (1 + np.tanh(self.data['LogReturn'])) / 2
        self.data['Sell%'] = (1 - np.tanh(self.data['LogReturn'])) / 2
        return self.data

    def apply_pca_calculations(self, pca_result):
        """Applies PCA-based calculations to the data."""
        pca_result = pca_result[pca_result['PC1'] > 0].copy()
        
        pca_result['PCA_LogReturn'] = np.log(pca_result['PC1'] / pca_result['PC1'].shift(1))
        pca_result.replace([np.inf, -np.inf], np.nan, inplace=True)
        pca_result.dropna(subset=['PCA_LogReturn'], inplace=True)
        
        pca_result['PCA_Scenario'] = np.where(pca_result['PCA_LogReturn'] > 0, 'Buy', 'Sell')
        pca_result['PCA_Buy%'] = (1 + np.tanh(pca_result['PCA_LogReturn'])) / 2
        pca_result['PCA_Sell%'] = (1 - np.tanh(pca_result['PCA_LogReturn'])) / 2
        
        self.data = self.data.merge(pca_result, left_index=True, right_index=True)
        return self.data

class PCATransformer:
    """Applies PCA to reduce dimensionality and extract features."""
    def __init__(self, n_components=1):
        self.n_components = n_components
        self.scaler = StandardScaler()
        self.pca = PCA(n_components=n_components)

    def fit_transform(self, data):
        numeric_data = data.select_dtypes(include=[np.number])
        scaled_data = self.scaler.fit_transform(numeric_data)
        pca_result = self.pca.fit_transform(scaled_data)
        return pd.DataFrame(pca_result, columns=[f'PC{i+1}' for i in range(self.n_components)], index=data.index)

class StrategyBuilder:
    """Builds and refines the trading strategy using machine learning and SHAP."""
    def __init__(self, data):
        self.data = data.copy()

    def train_model(self, target_column):
        X = self.data.select_dtypes(include=[np.number])
        y = self.data[target_column]
        y_encoded = LabelEncoder().fit_transform(y)
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X, y_encoded)
        return model, X, y_encoded

    def compute_shapley_values(self, model, X):
        explainer = shap.TreeExplainer(model)
        return explainer.shap_values(X)

    def analyze_feature_importance(self, shap_values, feature_names):
        """Analyzes feature importance based on SHAP values."""
        if isinstance(shap_values, list):
            shap_values = shap_values[1]

        if len(shap_values.shape) == 3:
            shap_values = shap_values[:, :, 1]

        mean_abs_shap = np.mean(np.abs(shap_values), axis=0)

        if len(mean_abs_shap) != len(feature_names):
            raise ValueError("Mismatch between SHAP values and feature names.")

        feature_importance = pd.DataFrame({
            'Feature': feature_names,
            'Mean_Abs_SHAP': mean_abs_shap
        }).sort_values(by='Mean_Abs_SHAP', ascending=False)

        return feature_importance

    def refine_thresholds(self, feature_importance, buy_threshold=0.5, sell_threshold=0.5):
        top_features = feature_importance.head(3)['Feature'].tolist()
        for feature in top_features:
            if 'Buy%' in feature or 'PCA_Buy%' in feature:
                buy_threshold *= 1.1
            elif 'Sell%' in feature or 'PCA_Sell%' in feature:
                sell_threshold *= 1.1
        return buy_threshold, sell_threshold

class Backtester:
    """Backtests the trading strategy on historical data."""
    def __init__(self, data):
        self.data = data.copy()

    def backtest(self, buy_threshold=0.5, sell_threshold=0.5):
        portfolio_value = 10000
        position = None
        entry_price = None
        portfolio_values = []
        last_buy_percentage = None
        last_sell_percentage = None

        for i in range(1, len(self.data)):
            last_row = self.data.iloc[i]
            if (last_row['PCA_Scenario'] == 'Buy' and last_row['PCA_Buy%'] > buy_threshold) or \
               (last_row['Scenario'] == 'Buy' and last_row['Buy%'] > buy_threshold):
                if position != 'Buy':
                    position = 'Buy'
                    entry_price = last_row['Close']
                    last_buy_percentage = last_row['PCA_Buy%'] if 'PCA_Buy%' in last_row else last_row['Buy%']
            elif (last_row['PCA_Scenario'] == 'Sell' and last_row['PCA_Sell%'] > sell_threshold) or \
                 (last_row['Scenario'] == 'Sell' and last_row['Sell%'] > sell_threshold):
                if position != 'Sell':
                    position = 'Sell'
                    entry_price = last_row['Close']
                    last_sell_percentage = last_row['PCA_Sell%'] if 'PCA_Sell%' in last_row else last_row['Sell%']

            if position == 'Buy':
                portfolio_value *= (last_row['Close'] / entry_price)
            elif position == 'Sell':
                portfolio_value *= (entry_price / last_row['Close'])

            portfolio_values.append(portfolio_value)

        return portfolio_values, position, entry_price, last_buy_percentage, last_sell_percentage

def run_analysis():
    """Runs the complete trading analysis."""
    try:
        # Load previous position
        current_position, entry_price, current_buy_percentage, current_sell_percentage = load_position()

        fetcher = DataFetcher(ticker="BTC-USD", nb_days=50)
        data = fetcher.fetch_data()

        processor = FinancialDataProcessor(data)
        processed_data = processor.calculate_returns().calculate_probabilities()

        pca_transformer = PCATransformer(n_components=1)
        pca_result = pca_transformer.fit_transform(processed_data)
        processed_data = processor.apply_pca_calculations(pca_result)

        strategy_builder = StrategyBuilder(processed_data)
        model, X, y_encoded = strategy_builder.train_model(target_column='PCA_Scenario')
        shap_values = strategy_builder.compute_shapley_values(model, X)

        feature_importance = strategy_builder.analyze_feature_importance(shap_values, X.columns)
        buy_threshold, sell_threshold = strategy_builder.refine_thresholds(feature_importance)

        backtester = Backtester(processed_data)
        portfolio_values, new_position, new_entry_price, new_buy_percentage, new_sell_percentage = backtester.backtest(buy_threshold, sell_threshold)

        last_row = processed_data.iloc[-1]

        # Display results
        col1, col2 = st.columns(2)

        with col1:
            st.subheader("Current Position")
            st.metric("Position", new_position or "No position")
            if new_position:
                st.metric("Entry Price", f"${new_entry_price:.2f}")

        with col2:
            st.subheader("Decision Metrics")
            st.metric("Buy%", f"{last_row['PCA_Buy%']:.4f}")
            st.metric("Sell%", f"{last_row['PCA_Sell%']:.4f}")


        # Save new position if changed
        if new_position != current_position:
            save_position(new_position, {"entry_price": new_entry_price, "timestamp": datetime.now().isoformat()},
                          buy_percentage=last_row['PCA_Buy%'], sell_percentage=last_row['PCA_Sell%'])


        
        return True

    except Exception as e:
        st.error(f"An error occurred: {str(e)}")
        return False

# Run analysis automatically on page load
run_analysis()


# Educational Slides Section
st.header("Educational Slides")

st.markdown('🎧Listen to the Audio🎧')
st.markdown(
    """
    <iframe src="https://drive.google.com/file/d/1oZdaiyrNYJ4v3LZ3lEurMSG3n784wiOw/preview" width="640" height="480"></iframe>
    """, unsafe_allow_html=True
)

st.markdown('Read the [White Paper](https://figshare.com/articles/thesis/Quantum_Principles_of_Time_and_Financial_Adaptation/28301660?file=51993188).')


st.markdown('Powered by [Forecast Trade Group](https://huggingface.co./TradeAdmin).')


with st.expander("Slide 1: Introduction", expanded=False):
    st.subheader("Real-Time Crypto Trading Bot Using Machine Learning and PCA")
    st.markdown("""
    **Subtitle:** Leveraging Financial Data Analysis for Optimal Trading Decisions
    
    **Overview:**  
    This system integrates real-time financial data, machine learning, and principal component analysis (PCA) 
    to automate trading decisions in cryptocurrency markets.
    """)

with st.expander("Slide 2: Objective", expanded=False):
    st.subheader("Main Goals")
    st.markdown("""
    - Develop an automated trading system that optimizes buy and sell decisions based on historical financial data
    - Use machine learning models, specifically Random Forest, to predict market movements
    - Implement Principal Component Analysis (PCA) for dimensionality reduction and feature extraction
    - Backtest the system and evaluate portfolio performance
    """)

with st.expander("Slide 3: Key Concepts", expanded=False):
    st.subheader("Core Technologies and Methods")
    st.markdown("""
    - **Logarithmic Return:** A continuous-time return calculation used to model price changes in markets
    - **Principal Component Analysis (PCA):** A dimensionality reduction technique to extract meaningful features
    - **Machine Learning:** Using Random Forest to classify "Buy" and "Sell" scenarios
    - **SHAP Values:** A method to interpret model outputs through feature contribution analysis
    """)

with st.expander("Slide 4: Data Collection and Preprocessing", expanded=False):
    col1, col2 = st.columns(2)
    with col1:
        st.markdown("### Data Fetching")
        st.markdown("""
        - **Source:** Yahoo Finance (yfinance)
        - **Data:** Historical cryptocurrency data
        - **Interval:** Hourly data points
        - **Period:** Last 50 days
        """)
    with col2:
        st.markdown("### Preprocessing")
        st.markdown("""
        - Calculate logarithmic returns
        - Classify scenarios (Buy/Sell)
        - Adjust returns for sell scenarios
        - Handle missing values and outliers
        """)

with st.expander("Slide 5: Principal Component Analysis (PCA)", expanded=False):
    st.subheader("PCA Process")
    st.markdown("""
    1. **Data Standardization:**
       ```
       X' = (X - μ) / σ
       ```
    
    2. **Covariance Matrix:**
       ```
       Cov(X) = 1/(n-1) Σ(Xi - μ)(Xi - μ)ᵀ
       ```
    
    3. **Eigenvalue Decomposition:**
       - Find principal components
       - Sort by variance explained
    
    4. **Dimensionality Reduction:**
       - Transform data to lower dimensions
       - Preserve important features
    """)

with st.expander("Slide 6: Machine Learning Strategy", expanded=False):
    col1, col2 = st.columns(2)
    with col1:
        st.markdown("### Model Architecture")
        st.markdown("""
        - Random Forest Classifier
        - Feature selection from PCA
        - Binary classification (Buy/Sell)
        """)
    with col2:
        st.markdown("### Training Process")
        st.markdown("""
        - Cross-validation
        - Hyperparameter tuning
        - Performance metrics
        - Model evaluation
        """)

with st.expander("Slide 7: SHAP Analysis", expanded=False):
    st.subheader("Shapley Additive Explanations")
    st.markdown("""
    **SHAP Value Formula:**
    ```
    φᵢ(f) = 1/|N|! Σ [f(S ∪ {i}) - f(S)]
    ```
    
    **Key Components:**
    - Feature importance ranking
    - Individual prediction explanations
    - Global model interpretation
    """)

with st.expander("Slide 8: Strategy Refinement", expanded=False):
    st.subheader("Dynamic Strategy Adjustment")
    st.markdown("""
    1. **Threshold Refinement:**
       - Use SHAP values to identify key features
       - Adjust thresholds based on importance
    
    2. **Signal Processing:**
       - Buy signal strengthening
       - Sell signal validation
       - Risk management integration
    """)

with st.expander("Slide 9: Backtesting Framework", expanded=False):
    st.markdown("""
    ### Portfolio Value Calculation
    ```
    Portfolio Valueₜ₊₁ = Portfolio Valueₜ × (Pₜ₊₁/Pₜ)
    ```
    
    ### Trading Logic
    - Buy when probability > threshold
    - Sell when probability > threshold
    - Position management
    
    ### Performance Metrics
    - Total Return
    - Risk Metrics
    - Sharpe Ratio
    """)

with st.expander("Slide 10: Real-Time Interface", expanded=False):
    st.subheader("Streamlit Dashboard Features")
    st.markdown("""
    - Live trading signals
    - Portfolio performance tracking
    - Position monitoring
    - Automatic updates
    - Historical performance
    """)

with st.expander("Slide 11: Summary", expanded=False):
    st.markdown("""
    ### Key System Components
    - Automated trading system
    - ML & PCA integration
    - SHAP-based interpretation
    - Real-time analytics
    - Performance tracking
    """)

with st.expander("Slide 12: Future Improvements", expanded=False):
    st.markdown("""
    ### Planned Enhancements
    1. Additional data sources integration
    2. Advanced optimization techniques
    3. Live trading deployment
    4. Enhanced risk management
    5. Portfolio diversification
    """)

with st.expander("Slide 13: Q&A", expanded=False):
    st.markdown("""
    ### Questions & Discussion
    
    Thank you for exploring our trading system! For questions or suggestions:
    - System architecture
    - Implementation details
    - Performance metrics
    - Future developments
    """)
st.markdown("---")
st.markdown("### Enjoying the Content?")
st.markdown("""
If you find our work useful and interesting, please consider supporting us for **free** on Publish0x!  
It's quick, easy, and no cost to you. Just follow this link to show your support:
[**Like and Tip Us for Free on Publish0x!**](https://www.publish0x.com/start/crypto-trading-mathematical-modeling-and-strategic-optimizat-xkelryw)
""")

# Footer
st.markdown("---")
st.markdown("*Support Development & Info : ")
st.markdown("Send your email in comment to your btc donation at ")
st.markdown("1P9R71C6JYJxrPVEzMz4K3hoHYGRW39A9A")
st.markdown('Join our [Community on Huggingface](https://huggingface.co./TradeAdmin) for more.')
st.markdown('All our bots are [tested on HTX](https://www.htx.com/invite/en-us/1f?invite_code=awhd9223).')

# Educational Slides Section dona