"""
CV6 AI Trading OS
Execution Engine
"""

from app.execution.order_manager import OrderManager
from app.execution.execution_models import ExecutionRequest, ExecutionResponse
from app.decision.decision_engine import DecisionEngine
from app.risk.risk_engine import RiskEngine


class ExecutionEngine:

    def __init__(self):
        self.order_manager = OrderManager()

    def execute(self, request: ExecutionRequest) -> ExecutionResponse:
        """Execute Trade"""
        return self.order_manager.place_order(request)

    def modify_order(self, broker: str, order_id: str, **kwargs):
        return self.order_manager.modify_order(broker_name=broker, order_id=order_id, **kwargs)

    def cancel_order(self, broker: str, order_id: str):
        return self.order_manager.cancel_order(broker_name=broker, order_id=order_id)

    def order_book(self, broker: str):
        return self.order_manager.order_book(broker_name=broker)

    def execute_trade(
        self,
        *,
        broker: str,
        symbol: str,
        exchange: str,
        capital: float,
        risk_percent: float,
        entry_price: float,
        stop_loss: float,
        target_price: float,
        ema: float,
        rsi: float,
        macd: float,
        supertrend: float,
        atr: float,
        vwap: float,
        strategy: str,
        confidence: float,
    ):
        decision_engine = DecisionEngine()
        risk_engine = RiskEngine()

        decision = decision_engine.decide(
            ema=ema, rsi=rsi, macd=macd, supertrend=supertrend,
            atr=atr, vwap=vwap, strategy=strategy, confidence=confidence,
        )

        if decision["decision"] == "HOLD":
            return {"success": False, "message": "Decision is HOLD", "decision": decision}

        risk = risk_engine.calculate(
            capital=capital, risk_percent=risk_percent,
            entry_price=entry_price, stop_loss=stop_loss, target_price=target_price,
        )

        if not risk["valid_trade"]:
            return {"success": False, "message": risk["message"], "risk": risk}

        request = ExecutionRequest(
            broker=broker, symbol=symbol, exchange=exchange,
            side=decision["decision"], quantity=risk["quantity"],
            order_type="MARKET", product="INTRADAY",
        )

        return self.execute(request)