from screener.user_input import get_interval_choice
import os
from datetime import datetime, timedelta
import pandas as pd
from db.db_connection import create_client
from trading.position_calculator import PositionCalculator
from screener.t_sunnyband import get_stock_data
from indicators.three_atr_ema import ThreeATREMAIndicator

def run_atr_ema_target_scanner(min_price: float, max_price: float, min_volume: int, portfolio_size: float = None):
    print(f"\n🔍 Scanning for stocks ${min_price:.2f}-${max_price:.2f} with min volume {min_volume:,}")
    
    interval = get_interval_choice()
    end_date = datetime.now()
    start_date = end_date - timedelta(days=1)  # Last trading day
    start_ts = int(start_date.timestamp() * 1e9)  # Convert to nanoseconds
    end_ts = int(end_date.timestamp() * 1e9)

    client = create_client()

    try:
        query = f"""
            WITH latest_data AS (
                SELECT 
                    ticker,
                    sum(volume) AS total_volume,
                    argMax(open, window_start) AS last_open,
                    argMax(close, window_start) AS last_close,
                    argMax(high, window_start) AS last_high,
                    argMax(low, window_start) AS last_low,
                    max(window_start) AS last_update,
                    sum(transactions) AS transaction_count
                FROM stock_db.stock_prices
                WHERE window_start BETWEEN {start_ts} AND {end_ts}
                GROUP BY ticker
                HAVING last_close BETWEEN {min_price} AND {max_price}
                AND total_volume >= {min_volume}
            )
            SELECT 
                ticker,
                total_volume,
                last_open,
                last_close,
                last_high,
                last_low,
                last_update,
                transaction_count
            FROM latest_data
            ORDER BY ticker
        """
        
        result = client.query(query)
        stocks = result.result_rows

        if not stocks:
            print("❌ No stocks found matching criteria.")
            return

        print(f"\n✅ Found {len(stocks)} stocks matching criteria")

        # **Correct column order as per ClickHouse output**
        columns = ["ticker", "volume", "open", "close", "high", "low", "window_start", "transactions"]
        df_stocks = pd.DataFrame(stocks, columns=columns)

        # **Convert timestamps from nanoseconds to readable datetime**
        df_stocks["window_start"] = pd.to_datetime(df_stocks["window_start"], unit="ns")

        # Debugging: Check if columns exist
        print("\n📊 Data Sample from ClickHouse Query:")
        print(df_stocks.head())

        indicator = ThreeATREMAIndicator()
        calculator = PositionCalculator(portfolio_size, risk_percentage=1.0, stop_loss_percentage=7.0) if portfolio_size else None
        bullish_signals = []

        for _, row in df_stocks.iterrows():
            ticker = row["ticker"]
            current_price = row["close"]
            current_volume = row["volume"]
            last_update = row["window_start"]

            try:
                df = get_stock_data(ticker, start_date, end_date, interval)

                # **Check if DataFrame has expected columns**
                if df.empty:
                    print(f"⚠️ No data found for {ticker}. Skipping.")
                    continue

                missing_cols = [col for col in ["close", "open", "high", "low", "volume"] if col not in df.columns]
                if missing_cols:
                    print(f"⚠️ {ticker} data is missing columns: {missing_cols}. Skipping.")
                    print(df.head())  # Debugging output
                    continue

                results = indicator.calculate(df)
                last_row = results.iloc[-1]
                prev_row = results.iloc[-2]

                bullish_entry = (
                    last_row["close"] < last_row["ema"] and 
                    prev_row["close"] <= prev_row["lower_band"] and 
                    last_row["close"] > prev_row["close"]
                )

                if bullish_entry:
                    entry_price = last_row["close"]
                    target_1 = entry_price * 1.10  # 10% profit
                    target_2 = entry_price * 1.20  # 20% profit

                    # Trailing stop logic
                    trail_stop = None
                    trail_active = False

                    if last_row["close"] >= last_row["upper_band"]:
                        trail_active = True
                        highest_price = max(results["high"].iloc[-5:])  # Last 5 days
                        trail_stop = highest_price * 0.98  # 2% below high

                    # Position sizing
                    position = calculator.calculate_position_size(entry_price, target_2) if calculator else None
                    position_size = position["position_value"] if position else None

                    # Save signal
                    signal_data = {
                        "ticker": ticker,
                        "entry_price": entry_price,
                        "target_1": target_1,
                        "target_2": target_2,
                        "volume": current_volume,
                        "last_update": last_update,
                        "trail_stop": trail_stop,
                        "position_size": position_size
                    }
                    bullish_signals.append(signal_data)

                    # Print result
                    print(f"\n🟢 {ticker} @ ${entry_price:.2f}")
                    print(f"   🎯 Target 1: ${target_1:.2f} | Target 2: ${target_2:.2f}")
                    if trail_active:
                        print(f"   🚨 Trailing Stop: ${trail_stop:.2f}")

            except Exception as e:
                print(f"❌ Error processing {ticker}: {e}")
                continue

        # Save results
        if bullish_signals:
            output_dir = "reports"
            os.makedirs(output_dir, exist_ok=True)
            output_file = f"{output_dir}/atr_ema_targets_{datetime.now().strftime('%Y%m%d_%H%M')}.csv"
            pd.DataFrame(bullish_signals).to_csv(output_file, index=False)
            print(f"\n📁 Saved bullish signals to {output_file}")
        else:
            print("❌ No bullish signals found.")

    except Exception as e:
        print(f"❌ Error during scan: {e}")