execution/mt5_executor.py

"""
MT5 local trade execution engine.
Handles opening and closing trades with safety checks.
"""

import asyncio
import logging
from datetime import datetime, timezone

from database import db as database
from config import MT5_LOGIN, MT5_PASSWORD, MT5_SERVER, MT5_SYMBOL_MAP

logger = logging.getLogger("gap_system.execution.mt5")


def _broker_symbol(asset: str) -> str:
    """Map internal asset name to broker MT5 symbol (e.g. XAUUSD → GOLD for XM)."""
    return MT5_SYMBOL_MAP.get(asset, asset)

_mt5_available = False

try:
    import MetaTrader5 as mt5
    _mt5_available = True
except ImportError:
    mt5 = None  # type: ignore
    logger.warning("MetaTrader5 package not installed — MT5 execution disabled")


async def initialize() -> bool:
    """Initialise MT5 connection."""
    if not _mt5_available:
        logger.warning("MT5 not available")
        return False

    try:
        result = await asyncio.to_thread(mt5.initialize)
        if not result:
            logger.error("MT5 initialise failed: %s", mt5.last_error())
            return False

        if MT5_LOGIN and MT5_LOGIN != "your_login":
            login_result = await asyncio.to_thread(
                mt5.login,
                int(MT5_LOGIN),
                password=MT5_PASSWORD,
                server=MT5_SERVER,
            )
            if not login_result:
                logger.error("MT5 login failed: %s", mt5.last_error())
                return False

        logger.info("MT5 initialised and logged in")
        return True

    except Exception as e:
        logger.error("MT5 init error: %s", e)
        return False


async def get_spread(symbol: str) -> float | None:
    """Get current spread in points."""
    if not _mt5_available:
        return None
    try:
        info = await asyncio.to_thread(mt5.symbol_info, symbol)
        if info is None:
            return None
        return float(info.spread)
    except Exception:
        return None


async def execute_trade(
    symbol: str,
    direction: str,
    lot_size: float,
    hold_seconds: int,
) -> dict:
    """
    Execute a trade on MT5: open, wait hold_seconds, then close.
    Returns result dict with entry/exit prices and P&L.
    """
    if not _mt5_available:
        return {"status": "failed", "error": "MT5 not available"}

    # Map internal name to broker symbol (e.g. "XAUUSD" → "GOLD" for XM)
    mt5_symbol = _broker_symbol(symbol)
    logger.info("Trading %s (broker symbol: %s)", symbol, mt5_symbol)

    # Safety check: spread
    spread = await get_spread(mt5_symbol)
    normal_spread = 30  # typical for gold
    if spread and spread > normal_spread * 3:
        error = f"Spread too high: {spread} (max {normal_spread * 3})"
        logger.warning(error)
        return {"status": "skipped", "error": error}

    try:
        # Get price
        tick = await asyncio.to_thread(mt5.symbol_info_tick, mt5_symbol)
        if tick is None:
            return {"status": "failed", "error": f"Could not get tick data for {mt5_symbol}"}

        if direction == "BULLISH":
            order_type = mt5.ORDER_TYPE_BUY
            price = tick.ask
        else:
            order_type = mt5.ORDER_TYPE_SELL
            price = tick.bid

        # Open trade
        request = {
            "action": mt5.TRADE_ACTION_DEAL,
            "symbol": mt5_symbol,
            "volume": lot_size,
            "type": order_type,
            "price": price,
            "deviation": 20,
            "magic": 99887766,
            "comment": f"GapAI_{direction}_{hold_seconds}s",
            "type_time": mt5.ORDER_TIME_GTC,
            "type_filling": mt5.ORDER_FILLING_IOC,
        }

        result = await asyncio.to_thread(mt5.order_send, request)

        if result is None or result.retcode != mt5.TRADE_RETCODE_DONE:
            error = f"Order failed: {result.comment if result else 'null result'}"
            logger.error(error)
            return {"status": "failed", "error": error}

        trade_id = await database.insert_trade(
            asset=symbol, direction=direction, lot_size=lot_size,
            hold_seconds=hold_seconds, entry_price=price,
        )

        logger.info("Trade opened: %s %s %.2f @ %.5f (hold %ds)",
                     symbol, direction, lot_size, price, hold_seconds)

        # Wait hold_seconds
        await asyncio.sleep(hold_seconds)

        # Close trade
        close_result = await _close_position(mt5_symbol, result.order, direction)

        if close_result["status"] == "closed":
            profit_pips = close_result.get("profit_pips", 0)
            profit_usd = close_result.get("profit_usd", 0)
            await database.close_trade(trade_id, close_result["exit_price"],
                                        profit_pips, profit_usd)

        return {
            "status": "closed",
            "entry_price": price,
            "exit_price": close_result.get("exit_price", 0),
            "profit_pips": close_result.get("profit_pips", 0),
            "profit_usd": close_result.get("profit_usd", 0),
            "hold_seconds": hold_seconds,
            "trade_id": trade_id,
        }

    except Exception as e:
        logger.error("Trade execution error: %s", e)
        return {"status": "failed", "error": str(e)}


async def _close_position(symbol: str, ticket: int, direction: str) -> dict:
    """Close an open position by ticket."""
    try:
        tick = await asyncio.to_thread(mt5.symbol_info_tick, symbol)
        if tick is None:
            return {"status": "failed", "error": "No tick data for close"}

        if direction == "BULLISH":
            close_type = mt5.ORDER_TYPE_SELL
            close_price = tick.bid
        else:
            close_type = mt5.ORDER_TYPE_BUY
            close_price = tick.ask

        request = {
            "action": mt5.TRADE_ACTION_DEAL,
            "symbol": symbol,
            "volume": 0.0,  # close full position
            "type": close_type,
            "position": ticket,
            "price": close_price,
            "deviation": 20,
            "magic": 99887766,
            "comment": "GapAI_close",
            "type_time": mt5.ORDER_TIME_GTC,
            "type_filling": mt5.ORDER_FILLING_IOC,
        }

        # Get position volume — MUST succeed or we assume position already closed
        positions = await asyncio.to_thread(mt5.positions_get, ticket=ticket)
        if positions and len(positions) > 0:
            request["volume"] = positions[0].volume
        else:
            # Position not found — it was already closed (SL/TP/manual)
            logger.info("Position %d not found — already closed", ticket)
            return {
                "status": "closed",
                "exit_price": close_price,
                "profit_pips": 0,
                "profit_usd": 0,
            }

        result = await asyncio.to_thread(mt5.order_send, request)

        if result and result.retcode == mt5.TRADE_RETCODE_DONE:
            logger.info("Trade closed @ %.5f", close_price)
            return {
                "status": "closed",
                "exit_price": close_price,
                "profit_pips": 0,  # calculated by caller
                "profit_usd": 0,
            }
        else:
            return {"status": "failed",
                    "error": f"Close failed: {result.comment if result else '?'}"}

    except Exception as e:
        logger.error("Close position error: %s", e)
        return {"status": "failed", "error": str(e)}