import os
import pandas as pd
import numpy as np
import streamlit as st
import plotly.express as px
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from dotenv import load_dotenv
import cloudscraper

# Load environment variables
load_dotenv()
API_KEY = os.environ.get("API_KEY")

# Check if API key is available
if not API_KEY:
    raise ValueError("API_KEY is not set. Please add it to your environment.")

# --- Helper Functions ---
def fetch_market_data(api_key, url):
    """Fetch market data using cloudscraper."""
    headers = {
        "Authorization": f"Bearer {api_key}",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36"
    }
    scraper = cloudscraper.create_scraper()
    response = scraper.get(url, headers=headers)
    response.raise_for_status()
    return response.json()

def preprocess_data(data):
    """Preprocess market data for AI analysis."""
    df = pd.DataFrame(data)
    if 'close_time' in df.columns:
        df['close_time'] = pd.to_datetime(df['close_time'], unit='ms', errors='coerce')
    return df

def train_predictive_model(df):
    """Train a simple predictive model based on historical data."""
    if 'close' not in df.columns or len(df) < 10:
        return None
    
    # Prepare data for training
    scaler = StandardScaler()
    X = np.arange(len(df)).reshape(-1, 1)  # Time indices
    y = df['close'].values.reshape(-1, 1)
    X_scaled = scaler.fit_transform(X)
    
    # Train linear regression model (example; replace with advanced models)
    model = LinearRegression()
    model.fit(X_scaled, y)
    
    # Predict future prices
    future_indices = np.arange(len(df), len(df) + 10).reshape(-1, 1)  # Next 10 time steps
    future_indices_scaled = scaler.transform(future_indices)
    predictions = model.predict(future_indices_scaled)
    
    return predictions

def display_predictions(predictions):
    """Display predictions in a Streamlit chart."""
    future_dates = pd.date_range(start=pd.Timestamp.now(), periods=len(predictions), freq='H')
    prediction_df = pd.DataFrame({'Date': future_dates, 'Predicted Close': predictions.flatten()})
    
    fig = px.line(prediction_df, x='Date', y='Predicted Close', title="Predicted Price Movement")
    st.plotly_chart(fig)

# --- Main Application ---
def main():
    st.title("AI-Driven Stock & Crypto Dashboard")
    
    # Fetch active markets from API
    url_active_markets = "https://archeanvision.com/api/signals/available"
    try:
        active_markets = fetch_market_data(API_KEY, url_active_markets)
        market_list = [market['market'] for market in active_markets]
        selected_market = st.selectbox("Select a Market", market_list)
        
        # Fetch market data for the selected market
        url_market_data = f"https://archeanvision.com/api/signals/{selected_market}/data"
        market_data = fetch_market_data(API_KEY, url_market_data)
        
        # Preprocess and display raw data
        df = preprocess_data(market_data)
        st.write("Market Data Overview:")
        st.dataframe(df.head())
        
        # Train predictive model and display predictions
        predictions = train_predictive_model(df)
        if predictions is not None:
            st.write(f"Predicted price movement for {selected_market}:")
            display_predictions(predictions)
        else:
            st.warning("Insufficient data or missing 'close' column for prediction.")
    
    except Exception as e:
        st.error(f"Error fetching or processing data: {e}")

if __name__ == "__main__":
    main()