from __future__ import annotations

import logging
import threading
from dataclasses import dataclass

from config.settings import settings

logger = logging.getLogger(__name__)


@dataclass
class TradingStats:
    balance: float
    initial_balance: float
    total_trades: int = 0
    winning_trades: int = 0
    losing_trades: int = 0
    total_pnl_pct: float = 0.0
    total_pnl_amount: float = 0.0

    @property
    def win_rate(self) -> float:
        return self.winning_trades / self.total_trades if self.total_trades else 0.0

    @property
    def total_return_pct(self) -> float:
        return (
            (self.balance - self.initial_balance) / self.initial_balance * 100
            if self.initial_balance
            else 0.0
        )

    def to_dict(self) -> dict:
        return {
            "balance": round(self.balance, 4),
            "initial_balance": self.initial_balance,
            "total_trades": self.total_trades,
            "winning_trades": self.winning_trades,
            "losing_trades": self.losing_trades,
            "win_rate": round(self.win_rate * 100, 2),
            "total_pnl_pct": round(self.total_pnl_pct, 4),
            "total_pnl_amount": round(self.total_pnl_amount, 4),
            "total_return_pct": round(self.total_return_pct, 4),
        }


class StatsTracker:
    """يتتبع إحصائيات التداول والرصيد."""

    def __init__(self) -> None:
        self._lock = threading.Lock()
        self._stats = TradingStats(
            balance=settings.INITIAL_BALANCE,
            initial_balance=settings.INITIAL_BALANCE,
        )

    def record_trade_closed(self, pnl_pct: float, quantity: float, entry_price: float) -> None:
        pnl_amount = quantity * entry_price * pnl_pct / 100
        with self._lock:
            self._stats.total_trades += 1
            self._stats.total_pnl_pct += pnl_pct
            self._stats.total_pnl_amount += pnl_amount
            self._stats.balance += pnl_amount
            if pnl_pct > 0:
                self._stats.winning_trades += 1
            else:
                self._stats.losing_trades += 1

        logger.info(
            f"إحصائيات محدَّثة: "
            f"صفقات={self._stats.total_trades} "
            f"فوز={self._stats.win_rate * 100:.1f}% "
            f"رصيد={self._stats.balance:.2f} USDT"
        )

    def get_stats(self) -> TradingStats:
        with self._lock:
            return TradingStats(
                balance=self._stats.balance,
                initial_balance=self._stats.initial_balance,
                total_trades=self._stats.total_trades,
                winning_trades=self._stats.winning_trades,
                losing_trades=self._stats.losing_trades,
                total_pnl_pct=self._stats.total_pnl_pct,
                total_pnl_amount=self._stats.total_pnl_amount,
            )

    @property
    def balance(self) -> float:
        with self._lock:
            return self._stats.balance


stats_tracker = StatsTracker()