import os
import threading
import time
from datetime import datetime, timedelta, timezone

from indian_paper_trading_strategy.engine.market import is_market_open, align_to_market_open
from indian_paper_trading_strategy.engine.execution import try_execute_sip
from indian_paper_trading_strategy.engine.broker import PaperBroker
from indian_paper_trading_strategy.engine.mtm import log_mtm, should_log_mtm
from indian_paper_trading_strategy.engine.state import load_state
from indian_paper_trading_strategy.engine.data import fetch_live_price
from indian_paper_trading_strategy.engine.history import load_monthly_close
from indian_paper_trading_strategy.engine.strategy import allocation
from indian_paper_trading_strategy.engine.time_utils import normalize_logical_time

from indian_paper_trading_strategy.engine.db import db_transaction, insert_engine_event, run_with_retry, get_context, set_context


def _update_engine_status(user_id: str, run_id: str, status: str):
    now = datetime.utcnow().replace(tzinfo=timezone.utc)

    def _op(cur, _conn):
        cur.execute(
            """
            INSERT INTO engine_status (user_id, run_id, status, last_updated)
            VALUES (%s, %s, %s, %s)
            ON CONFLICT (user_id, run_id) DO UPDATE
            SET status = EXCLUDED.status,
                last_updated = EXCLUDED.last_updated
            """,
            (user_id, run_id, status, now),
        )

    run_with_retry(_op)

NIFTY = "NIFTYBEES.NS"
GOLD = "GOLDBEES.NS"
SMA_MONTHS = 36

_DEFAULT_ENGINE_STATE = {
    "state": "STOPPED",
    "run_id": None,
    "user_id": None,
    "last_heartbeat_ts": None,
}

_ENGINE_STATES = {}
_ENGINE_STATES_LOCK = threading.Lock()

_RUNNERS = {}
_RUNNERS_LOCK = threading.Lock()

engine_state = _ENGINE_STATES


def _state_key(user_id: str, run_id: str):
    return (user_id, run_id)


def _get_state(user_id: str, run_id: str):
    key = _state_key(user_id, run_id)
    with _ENGINE_STATES_LOCK:
        state = _ENGINE_STATES.get(key)
        if state is None:
            state = dict(_DEFAULT_ENGINE_STATE)
            state["user_id"] = user_id
            state["run_id"] = run_id
            _ENGINE_STATES[key] = state
        return state


def _set_state(user_id: str, run_id: str, **updates):
    key = _state_key(user_id, run_id)
    with _ENGINE_STATES_LOCK:
        state = _ENGINE_STATES.get(key)
        if state is None:
            state = dict(_DEFAULT_ENGINE_STATE)
            state["user_id"] = user_id
            state["run_id"] = run_id
            _ENGINE_STATES[key] = state
        state.update(updates)


def get_engine_state(user_id: str, run_id: str):
    state = _get_state(user_id, run_id)
    return dict(state)

def log_event(
    event: str,
    data: dict | None = None,
    message: str | None = None,
    meta: dict | None = None,
):
    entry = {
        "ts": datetime.utcnow().replace(tzinfo=timezone.utc).isoformat(),
        "event": event,
    }
    if message is not None or meta is not None:
        entry["message"] = message or ""
        entry["meta"] = meta or {}
    else:
        entry["data"] = data or {}
    event_ts = datetime.fromisoformat(entry["ts"].replace("Z", "+00:00"))
    data = entry.get("data") if "data" in entry else None
    meta = entry.get("meta") if "meta" in entry else None

    def _op(cur, _conn):
        insert_engine_event(
            cur,
            entry.get("event"),
            data=data,
            message=entry.get("message"),
            meta=meta,
            ts=event_ts,
        )

    run_with_retry(_op)

def sleep_with_heartbeat(
    total_seconds: int,
    stop_event: threading.Event,
    user_id: str,
    run_id: str,
    step_seconds: int = 5,
):
    remaining = total_seconds
    while remaining > 0 and not stop_event.is_set():
        time.sleep(min(step_seconds, remaining))
        _set_state(user_id, run_id, last_heartbeat_ts=datetime.utcnow().isoformat() + "Z")
        remaining -= step_seconds

def _clear_runner(user_id: str, run_id: str):
    key = _state_key(user_id, run_id)
    with _RUNNERS_LOCK:
        _RUNNERS.pop(key, None)

def can_execute(now: datetime) -> tuple[bool, str]:
    if not is_market_open(now):
        return False, "MARKET_CLOSED"
    return True, "OK"

def _engine_loop(config, stop_event: threading.Event):
    print("Strategy engine started with config:", config)

    user_id = config.get("user_id")
    run_id = config.get("run_id")
    scope_user, scope_run = get_context(user_id, run_id)
    set_context(scope_user, scope_run)

    strategy_name = config.get("strategy_name") or config.get("strategy") or "golden_nifty"
    sip_amount = config["sip_amount"]
    configured_frequency = config.get("sip_frequency") or {}
    if not isinstance(configured_frequency, dict):
        configured_frequency = {}
    frequency_value = int(configured_frequency.get("value", config.get("frequency", 0)))
    frequency_unit = configured_frequency.get("unit", config.get("unit", "days"))
    frequency_label = f"{frequency_value} {frequency_unit}"
    emit_event_cb = config.get("emit_event")
    if not callable(emit_event_cb):
        emit_event_cb = None
    debug_enabled = os.getenv("ENGINE_DEBUG", "1").strip().lower() not in {"0", "false", "no"}

    def debug_event(event: str, message: str, meta: dict | None = None):
        if not debug_enabled:
            return
        try:
            log_event(event=event, message=message, meta=meta or {})
        except Exception:
            pass
        if emit_event_cb:
            emit_event_cb(event=event, message=message, meta=meta or {})
        print(f"[ENGINE] {event} {message} {meta or {}}", flush=True)
    mode = (config.get("mode") or "LIVE").strip().upper()
    if mode not in {"PAPER", "LIVE"}:
        mode = "LIVE"
    broker_type = config.get("broker") or "paper"
    if broker_type != "paper":
        broker_type = "paper"
    if broker_type == "paper":
        mode = "PAPER"
    initial_cash = float(config.get("initial_cash", 0))
    broker = PaperBroker(initial_cash=initial_cash)
    log_event(
        event="DEBUG_PAPER_STORE_PATH",
        message="Paper broker store path",
        meta={
            "cwd": os.getcwd(),
            "paper_store_path": str(broker.store_path) if hasattr(broker, "store_path") else "NO_STORE_PATH",
            "abs_store_path": os.path.abspath(str(broker.store_path)) if hasattr(broker, "store_path") else "N/A",
        },
    )
    if emit_event_cb:
        emit_event_cb(
            event="DEBUG_PAPER_STORE_PATH",
            message="Paper broker store path",
            meta={
                "cwd": os.getcwd(),
                "paper_store_path": str(broker.store_path) if hasattr(broker, "store_path") else "NO_STORE_PATH",
                "abs_store_path": os.path.abspath(str(broker.store_path)) if hasattr(broker, "store_path") else "N/A",
            },
        )

    log_event("ENGINE_START", {
        "strategy": strategy_name,
        "sip_amount": sip_amount,
        "frequency": frequency_label,
    })
    debug_event("ENGINE_START_DEBUG", "engine loop started", {"run_id": scope_run, "user_id": scope_user})

    _set_state(
        scope_user,
        scope_run,
        state="RUNNING",
        last_heartbeat_ts=datetime.utcnow().isoformat() + "Z",
    )
    _update_engine_status(scope_user, scope_run, "RUNNING")

    try:
        while not stop_event.is_set():
            _set_state(scope_user, scope_run, last_heartbeat_ts=datetime.utcnow().isoformat() + "Z")
            _update_engine_status(scope_user, scope_run, "RUNNING")
            
            state = load_state(mode=mode)
            debug_event(
                "STATE_LOADED",
                "loaded engine state",
                {
                    "last_sip_ts": state.get("last_sip_ts"),
                    "last_run": state.get("last_run"),
                    "cash": state.get("cash"),
                    "total_invested": state.get("total_invested"),
                },
            )
            state_frequency = state.get("sip_frequency")
            if not isinstance(state_frequency, dict):
                state_frequency = {"value": frequency_value, "unit": frequency_unit}
            freq = int(state_frequency.get("value", frequency_value))
            unit = state_frequency.get("unit", frequency_unit)
            frequency_label = f"{freq} {unit}"
            if unit == "minutes":
                delta = timedelta(minutes=freq)
            else:
                delta = timedelta(days=freq)

            # Gate 2: time to SIP
            last_run = state.get("last_run") or state.get("last_sip_ts")
            is_first_run = last_run is None
            now = datetime.now()
            debug_event(
                "ENGINE_LOOP_TICK",
                "engine loop tick",
                {"now": now.isoformat(), "frequency": frequency_label},
            )

            if last_run and not is_first_run:
                next_run = datetime.fromisoformat(last_run) + delta
                next_run = align_to_market_open(next_run)
                if now < next_run:
                    log_event(
                        event="SIP_WAITING",
                        message="Waiting for next SIP window",
                        meta={
                            "last_run": last_run,
                            "next_eligible": next_run.isoformat(),
                            "now": now.isoformat(),
                            "frequency": frequency_label,
                        },
                    )
                    if emit_event_cb:
                        emit_event_cb(
                            event="SIP_WAITING",
                            message="Waiting for next SIP window",
                            meta={
                                "last_run": last_run,
                                "next_eligible": next_run.isoformat(),
                                "now": now.isoformat(),
                                "frequency": frequency_label,
                            },
                        )
                    sleep_with_heartbeat(60, stop_event, scope_user, scope_run)
                    continue

            try:
                debug_event("PRICE_FETCH_START", "fetching live prices", {"tickers": [NIFTY, GOLD]})
                nifty_price = fetch_live_price(NIFTY)
                gold_price = fetch_live_price(GOLD)
                debug_event(
                    "PRICE_FETCHED",
                    "fetched live prices",
                    {"nifty_price": float(nifty_price), "gold_price": float(gold_price)},
                )
            except Exception as exc:
                debug_event("PRICE_FETCH_ERROR", "live price fetch failed", {"error": str(exc)})
                sleep_with_heartbeat(30, stop_event, scope_user, scope_run)
                continue

            try:
                nifty_hist = load_monthly_close(NIFTY)
                gold_hist = load_monthly_close(GOLD)
            except Exception as exc:
                debug_event("HISTORY_LOAD_ERROR", "history load failed", {"error": str(exc)})
                sleep_with_heartbeat(30, stop_event, scope_user, scope_run)
                continue

            nifty_sma = nifty_hist.rolling(SMA_MONTHS).mean().iloc[-1]
            gold_sma = gold_hist.rolling(SMA_MONTHS).mean().iloc[-1]

            eq_w, gd_w = allocation(
                sp_price=nifty_price,
                gd_price=gold_price,
                sp_sma=nifty_sma,
                gd_sma=gold_sma
            )
            debug_event(
                "WEIGHTS_COMPUTED",
                "computed allocation weights",
                {"equity_weight": float(eq_w), "gold_weight": float(gd_w)},
            )

            weights = {"equity": eq_w, "gold": gd_w}
            allowed, reason = can_execute(now)
            executed = False
            if not allowed:
                log_event(
                    event="EXECUTION_BLOCKED",
                    message="Execution blocked by market gate",
                    meta={
                        "reason": reason,
                        "eligible_since": last_run,
                        "checked_at": now.isoformat(),
                    },
                )
                debug_event("MARKET_GATE", "market closed", {"reason": reason})
                if emit_event_cb:
                    emit_event_cb(
                        event="EXECUTION_BLOCKED",
                        message="Execution blocked by market gate",
                        meta={
                            "reason": reason,
                            "eligible_since": last_run,
                            "checked_at": now.isoformat(),
                        },
                    )
            else:
                log_event(
                    event="DEBUG_BEFORE_TRY_EXECUTE",
                    message="About to call try_execute_sip",
                    meta={
                        "last_run": last_run,
                        "frequency": frequency_label,
                        "allowed": allowed,
                        "reason": reason,
                        "sip_amount": sip_amount,
                        "broker": type(broker).__name__,
                        "now": now.isoformat(),
                    },
                )
                if emit_event_cb:
                    emit_event_cb(
                        event="DEBUG_BEFORE_TRY_EXECUTE",
                        message="About to call try_execute_sip",
                        meta={
                            "last_run": last_run,
                            "frequency": frequency_label,
                            "allowed": allowed,
                            "reason": reason,
                            "sip_amount": sip_amount,
                            "broker": type(broker).__name__,
                            "now": now.isoformat(),
                        },
                    )
                debug_event(
                    "TRY_EXECUTE_START",
                    "calling try_execute_sip",
                    {"sip_interval_sec": delta.total_seconds(), "sip_amount": sip_amount},
                )
                state, executed = try_execute_sip(
                    now=now,
                    market_open=True,
                    sip_interval=delta.total_seconds(),
                    sip_amount=sip_amount,
                    sp_price=nifty_price,
                    gd_price=gold_price,
                    eq_w=eq_w,
                    gd_w=gd_w,
                    broker=broker,
                    mode=mode,
                )
                log_event(
                    event="DEBUG_AFTER_TRY_EXECUTE",
                    message="Returned from try_execute_sip",
                    meta={
                        "executed": executed,
                        "state_last_run": state.get("last_run"),
                        "state_last_sip_ts": state.get("last_sip_ts"),
                    },
                )
                if emit_event_cb:
                    emit_event_cb(
                        event="DEBUG_AFTER_TRY_EXECUTE",
                        message="Returned from try_execute_sip",
                        meta={
                            "executed": executed,
                            "state_last_run": state.get("last_run"),
                            "state_last_sip_ts": state.get("last_sip_ts"),
                        },
                    )
                debug_event(
                    "TRY_EXECUTE_DONE",
                    "try_execute_sip finished",
                    {"executed": executed, "last_run": state.get("last_run")},
                )

            if executed:
                log_event("SIP_TRIGGERED", {
                    "date": now.date().isoformat(),
                    "allocation": weights,
                    "cash_used": sip_amount
                })
                debug_event("SIP_TRIGGERED", "sip executed", {"cash_used": sip_amount})
                portfolio_value = (
                    state["nifty_units"] * nifty_price
                    + state["gold_units"] * gold_price
                )
                log_event("PORTFOLIO_UPDATED", {
                    "nifty_units": state["nifty_units"],
                    "gold_units": state["gold_units"],
                    "portfolio_value": portfolio_value
                })
                print("SIP executed at", now)

            if should_log_mtm(None, now):
                logical_time = normalize_logical_time(now)
                with db_transaction() as cur:
                    log_mtm(
                        nifty_units=state["nifty_units"],
                        gold_units=state["gold_units"],
                        nifty_price=nifty_price,
                        gold_price=gold_price,
                        total_invested=state["total_invested"],
                        cur=cur,
                        logical_time=logical_time,
                    )
                    broker.update_equity(
                        {NIFTY: nifty_price, GOLD: gold_price},
                        now,
                        cur=cur,
                        logical_time=logical_time,
                    )

            sleep_with_heartbeat(30, stop_event, scope_user, scope_run)
    except Exception as e:
        _set_state(scope_user, scope_run, state="ERROR", last_heartbeat_ts=datetime.utcnow().isoformat() + "Z")
        _update_engine_status(scope_user, scope_run, "ERROR")
        log_event("ENGINE_ERROR", {"error": str(e)})
        raise

    log_event("ENGINE_STOP")
    _set_state(
        scope_user,
        scope_run,
        state="STOPPED",
        last_heartbeat_ts=datetime.utcnow().isoformat() + "Z",
    )
    _update_engine_status(scope_user, scope_run, "STOPPED")
    print("Strategy engine stopped")
    _clear_runner(scope_user, scope_run)

def start_engine(config):
    user_id = config.get("user_id")
    run_id = config.get("run_id")
    if not user_id:
        raise ValueError("user_id is required to start engine")
    if not run_id:
        raise ValueError("run_id is required to start engine")

    with _RUNNERS_LOCK:
        key = _state_key(user_id, run_id)
        runner = _RUNNERS.get(key)
        if runner and runner["thread"].is_alive():
            return False

        stop_event = threading.Event()
        thread = threading.Thread(
            target=_engine_loop,
            args=(config, stop_event),
            daemon=True,
        )
        _RUNNERS[key] = {"thread": thread, "stop_event": stop_event}
        thread.start()
        return True

def stop_engine(user_id: str, run_id: str | None = None, timeout: float | None = 10.0):
    runners = []
    with _RUNNERS_LOCK:
        if run_id:
            key = _state_key(user_id, run_id)
            runner = _RUNNERS.get(key)
            if runner:
                runners.append((key, runner))
        else:
            for key, runner in list(_RUNNERS.items()):
                if key[0] == user_id:
                    runners.append((key, runner))
        for _key, runner in runners:
            runner["stop_event"].set()
    stopped_all = True
    for key, runner in runners:
        thread = runner["thread"]
        if timeout is not None:
            thread.join(timeout=timeout)
        stopped = not thread.is_alive()
        if stopped:
            _clear_runner(key[0], key[1])
        else:
            stopped_all = False
    return stopped_all