"""
AkDevz AI Market Intelligence — Authentic Candles & Overlays Worker
Provides real exchange candlestick series with technical overlays for TradingView Lightweight Charts.
"""
import sys
from pathlib import Path

PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent
if str(PROJECT_ROOT) not in sys.path:
    sys.path.insert(0, str(PROJECT_ROOT))

import json
import argparse
import numpy as np

from python.data.market_feed import MarketFeed
from python.data.data_normalizer import DataNormalizer
from python.analytics.technical_engine import TechnicalEngine
from python.analytics.support_resistance import SupportResistanceEngine

def get_chart_data(symbol: str, timeframe: str = "5m", count: int = 100) -> dict:
    raw_candles = MarketFeed.get_real_candles(symbol, count=count, timeframe=timeframe)
    if not raw_candles or len(raw_candles) < 5:
        return {
            "status": "error",
            "symbol": symbol,
            "message": "Insufficient real market data available."
        }

    norm_candles = DataNormalizer.normalize_candles(raw_candles)
    np_data = DataNormalizer.to_numpy_arrays(norm_candles)

    c = np_data["close"]
    h = np_data["high"]
    l = np_data["low"]
    v = np_data["volume"]
    times = [int(cd[0]) for cd in raw_candles]

    # Calculate Overlays
    vwap = TechnicalEngine.calculate_vwap(h, l, c, v)
    ema_9 = TechnicalEngine.calculate_ema(c, 9)
    ema_20 = TechnicalEngine.calculate_ema(c, 20)

    # Calculate Pivots for horizontal support/resistance
    pivots = SupportResistanceEngine.calculate_daily_pivots(
        high=float(np.max(h[-75:])),
        low=float(np.min(l[-75:])),
        close=float(c[-1])
    )

    candles_out = []
    volume_out = []
    vwap_out = []
    ema9_out = []
    ema20_out = []

    for i in range(len(raw_candles)):
        t = times[i]
        o_val = float(norm_candles[i]["open"])
        h_val = float(norm_candles[i]["high"])
        l_val = float(norm_candles[i]["low"])
        c_val = float(norm_candles[i]["close"])
        v_val = float(norm_candles[i]["volume"])

        candles_out.append({
            "time": t,
            "open": round(o_val, 2),
            "high": round(h_val, 2),
            "low": round(l_val, 2),
            "close": round(c_val, 2)
        })

        is_up = c_val >= o_val
        vol_color = "rgba(34, 197, 94, 0.45)" if is_up else "rgba(239, 68, 68, 0.45)"
        volume_out.append({
            "time": t,
            "value": round(v_val, 2),
            "color": vol_color
        })

        if not np.isnan(vwap[i]):
            vwap_out.append({"time": t, "value": round(float(vwap[i]), 2)})
        if not np.isnan(ema_9[i]):
            ema9_out.append({"time": t, "value": round(float(ema_9[i]), 2)})
        if not np.isnan(ema_20[i]):
            ema20_out.append({"time": t, "value": round(float(ema_20[i]), 2)})

    return {
        "status": "success",
        "symbol": symbol,
        "timeframe": timeframe,
        "candles": candles_out,
        "volume": volume_out,
        "overlays": {
            "vwap": vwap_out,
            "ema9": ema9_out,
            "ema20": ema20_out
        },
        "pivots": pivots,
        "latest": {
            "ltp": round(float(c[-1]), 2),
            "open": round(float(norm_candles[-1]["open"]), 2),
            "high": round(float(norm_candles[-1]["high"]), 2),
            "low": round(float(norm_candles[-1]["low"]), 2),
            "close": round(float(c[-1]), 2),
            "volume": round(float(v[-1]), 2)
        }
    }

def main():
    parser = argparse.ArgumentParser(description="Candles Worker for Lightweight Charts")
    parser.add_argument("--symbol", type=str, default="NSE:NIFTY50-INDEX")
    parser.add_argument("--timeframe", type=str, default="5m")
    parser.add_argument("--count", type=int, default=100)
    args = parser.parse_args()

    data = get_chart_data(args.symbol, args.timeframe, args.count)
    print(json.dumps(data))

if __name__ == "__main__":
    main()