"""수동 청산 공용 부기 (M-5 2026-10-02) — CLAUDE.md §3.2·§3.5·§5.3.

수동 청산 3경로(`/portfolio/sell` 레거시, `/portfolio/v2/sell`, `/swing/sell`)가 각자
다르게 부기하면서 생긴 결함을 한 곳에서 정리한다.

  - Portfolio 행은 stock_code UNIQUE 라 스윙+DT 수량이 합산돼 있다(§3.5).
    매도 수량을 **DT 우선** 으로 배분해(mdd_manager 축소 반영과 같은 규칙) ActiveTrade 와
    DT 인메모리를 각각 갱신한다. `/swing/sell` 은 스윙분만 판다(DT 배분 0).
  - ActiveTrade close/upsert 에는 **항상 전략명 필터**를 싣는다. 전략명이 없으면 db_worker 가
    '가장 최근 active 행'을 매칭해 DT 행을 오폐기한다(§5.3, 2026-09-23 유령 행 129개).
      비-DT: strategy_name_not=DT_STRATEGY_NAMES (NULL 포함) / DT: strategy_names=DT
  - DB 쓰기는 전부 db_worker 큐 경유(§3.2). 이 모듈은 세션을 열지 않는다.

주문 자체는 호출부가 `trade_executor.safe_place_order(_v2)`(세마포어+Redis 락)로 낸다.
"""
from __future__ import annotations

import logging
from dataclasses import dataclass
from typing import Optional

from app.services.db_worker import DT_STRATEGY_NAMES

logger = logging.getLogger(__name__)


@dataclass(frozen=True)
class SellAllocation:
    """매도 수량의 전략별 배분 (DT 우선)."""

    sold: int
    row_qty_before: int
    dt_before: int      # 행 수량으로 클램프된 DT 보유분
    dt_sold: int
    swing_sold: int

    @property
    def swing_before(self) -> int:
        return max(0, self.row_qty_before - self.dt_before)

    @property
    def swing_left(self) -> int:
        return max(0, self.swing_before - self.swing_sold)

    @property
    def dt_left(self) -> int:
        return max(0, self.dt_before - self.dt_sold)


def dt_inmemory_qty_v2(stock_code: str) -> Optional[int]:
    """DT 인메모리 보유 수량. 조회 실패 시 None(호출부가 '확인 불가'로 취급)."""
    try:
        from app.services.daytrading.position_manager import day_trading_state as _dts
        return int((_dts.positions.get(stock_code) or {}).get("quantity", 0) or 0)
    except Exception as e:
        logger.warning(f"[MANUAL_SELL] {stock_code}: DT 인메모리 수량 조회 실패: {e}")
        return None


def allocate_sell_v2(
    sold: int, row_qty_before: int, dt_qty: int, swing_only: bool
) -> SellAllocation:
    """매도 수량 배분. swing_only=True 면 DT 배분 0(스윙분만 판다)."""
    row = max(0, int(row_qty_before))
    dt = min(max(0, int(dt_qty)), row)  # 인메모리가 행보다 크면 stale — 행으로 클램프
    sold = max(0, int(sold))
    dt_sold = 0 if swing_only else min(dt, sold)
    return SellAllocation(
        sold=sold, row_qty_before=row, dt_before=dt,
        dt_sold=dt_sold, swing_sold=sold - dt_sold,
    )


async def sync_active_trade_after_manual_sell_v2(
    stock_code: str,
    alloc: SellAllocation,
    price: Optional[float] = None,
    user_id: Optional[int] = None,
) -> None:
    """ActiveTrade 를 전략별로 갱신 (db_worker 큐, 전략명 필터 명시)."""
    from app.services.db_worker import enqueue_active_trade_upsert, enqueue_db_write

    async def _close(**flt) -> None:
        data: dict = {"stock_code": stock_code, **flt}
        if user_id is not None:
            data["user_id"] = user_id
        await enqueue_db_write({"type": "close_active_trade", "data": data})

    async def _upsert(qty: int, ratio: Optional[float], **flt) -> None:
        payload: dict = {"stock_code": stock_code, "quantity": qty, **flt}
        if ratio is not None:
            # sell_pct 규약(원본 대비)과 맞추기 위해 남은 비율을 누적 곱한다(MDD 반영과 동일)
            payload["remaining_pct_multiply"] = ratio
        if price:
            payload["current_price"] = float(price)
        if user_id is not None:
            payload["user_id"] = user_id
        await enqueue_active_trade_upsert(payload)

    if alloc.swing_sold > 0:
        if alloc.swing_left <= 0:
            await _close(strategy_name_not=DT_STRATEGY_NAMES)
        else:
            ratio = alloc.swing_left / alloc.swing_before if alloc.swing_before > 0 else None
            await _upsert(alloc.swing_left, ratio, strategy_name_not=DT_STRATEGY_NAMES)
    if alloc.dt_sold > 0:
        if alloc.dt_left <= 0:
            await _close(strategy_names=list(DT_STRATEGY_NAMES))
        else:
            await _upsert(alloc.dt_left, None, strategy_names=list(DT_STRATEGY_NAMES))


async def reflect_dt_after_manual_sell_v2(stock_code: str, dt_sold: int) -> None:
    """DT 인메모리 포지션에서 dt_sold 만큼 차감. 전량이면 제거 + 일일 안전장치 저장.

    trade_lock 안에서는 상태만 바꾸고, Redis 저장은 락 해제 후(§3.1).
    """
    if dt_sold <= 0:
        return
    removed = False
    try:
        from app.services.daytrading.position_manager import day_trading_state as _dts
        async with _dts.trade_lock:
            pos = _dts.positions.get(stock_code)
            if pos:
                left = max(0, int(pos.get("quantity", 0) or 0) - int(dt_sold))
                if left <= 0:
                    _dts.remove_position(stock_code)  # closed_today 추가 → 당일 재진입 차단
                    removed = True
                    logger.warning(f"[MANUAL_SELL] DT 포지션 제거(수동 매도): {stock_code}")
                else:
                    pos["quantity"] = left
                    logger.warning(f"[MANUAL_SELL] DT 포지션 잔량 갱신(수동 매도): {stock_code} → {left}주")
    except Exception as e:
        logger.warning(f"[MANUAL_SELL] DT 인메모리 반영 실패 {stock_code}: {e}")
    if removed:
        try:
            from app.services.daytrading.position_manager import day_trading_state as _dts_save
            await _dts_save.save_daily_state()
        except Exception as e:
            logger.warning(
                f"[MANUAL_SELL] DT 일일 안전장치 저장 실패 ({stock_code}): {e} — 재기동 시 "
                f"당일 재진입 차단이 풀릴 수 있다"
            )