"""Multi-timeframe ICT analysis.

Combines Higher, Middle, and Lower timeframe signals to determine
market bias, key zones, and precise entry points.
"""

from __future__ import annotations

from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional

import pandas as pd
from loguru import logger

from config import settings
from core.data_feed import DataFeed
from indicators.ict_engine import ICTEngine, ICTSignals


class MarketBias(str, Enum):
    BULLISH = "BULLISH"
    BEARISH = "BEARISH"
    NEUTRAL = "NEUTRAL"


class TradeDirection(str, Enum):
    LONG = "LONG"
    SHORT = "SHORT"
    NONE = "NONE"


@dataclass
class TradeZone:
    """A price zone of interest (OB or FVG)."""

    zone_type: str       # "OB" or "FVG"
    direction: int       # 1 = bullish, -1 = bearish
    top: float
    bottom: float
    timeframe: str
    strength: float = 1.0

    @property
    def mid(self) -> float:
        return (self.top + self.bottom) / 2

    def contains_price(self, price: float) -> bool:
        return self.bottom <= price <= self.top


@dataclass
class EntryPoint:
    """Precise entry details derived from LTF analysis."""

    direction: TradeDirection
    price: float
    stop_loss: float
    take_profit: float
    zone: TradeZone
    timeframe: str


@dataclass
class MTFAnalysis:
    """Result of multi-timeframe analysis."""

    htf_bias: MarketBias
    mtf_zones: List[TradeZone] = field(default_factory=list)
    ltf_entry: Optional[EntryPoint] = None
    confluence_score: int = 0


class MultiTimeframeAnalyzer:
    """Analyze market structure across Higher, Middle, and Lower timeframes."""

    TIMEFRAMES = {
        "htf": settings.HTF_TIMEFRAME,
        "mtf": settings.MTF_TIMEFRAME,
        "ltf": settings.LTF_TIMEFRAME,
    }

    def __init__(self, ict_engine: ICTEngine):
        self.engine = ict_engine

    async def analyze_all(
        self, data_feed: DataFeed, symbol: str
    ) -> MTFAnalysis:
        """Run ICT analysis on all three timeframes and synthesise results."""
        # Fetch data for all timeframes
        tf_data = await data_feed.fetch_multi_timeframe(
            symbol, list(self.TIMEFRAMES.values())
        )

        htf_df = tf_data[self.TIMEFRAMES["htf"]]
        mtf_df = tf_data[self.TIMEFRAMES["mtf"]]
        ltf_df = tf_data[self.TIMEFRAMES["ltf"]]

        # Analyze each timeframe
        htf_signals = self.engine.analyze(htf_df)
        mtf_signals = self.engine.analyze(mtf_df)
        ltf_signals = self.engine.analyze(ltf_df)

        # Determine bias from HTF
        bias = self.get_htf_bias(htf_signals)

        # Find key zones from MTF
        zones = self.find_mtf_zones(mtf_signals, self.TIMEFRAMES["mtf"])

        # Find precise entry from LTF
        current_price = float(ltf_df["close"].iloc[-1])
        entry = self.find_ltf_entry(ltf_signals, bias, zones, current_price)

        # Calculate confluence
        score = self._calculate_confluence(htf_signals, mtf_signals, ltf_signals, bias)

        result = MTFAnalysis(
            htf_bias=bias,
            mtf_zones=zones,
            ltf_entry=entry,
            confluence_score=score,
        )
        logger.info(
            "MTF Analysis for {}: bias={}, zones={}, score={}",
            symbol, bias.value, len(zones), score,
        )
        return result

    def get_htf_bias(self, htf_signals: ICTSignals) -> MarketBias:
        """Determine overall market direction from the Higher Timeframe.

        Uses BOS/CHOCH and swing structure to decide bias.
        """
        latest_bos = htf_signals.latest_bos
        latest_choch = htf_signals.latest_choch

        # CHOCH takes precedence (trend reversal)
        if latest_choch == 1:
            return MarketBias.BULLISH
        if latest_choch == -1:
            return MarketBias.BEARISH

        # BOS confirms existing trend
        if latest_bos == 1:
            return MarketBias.BULLISH
        if latest_bos == -1:
            return MarketBias.BEARISH

        return MarketBias.NEUTRAL

    def find_mtf_zones(
        self, mtf_signals: ICTSignals, timeframe: str
    ) -> List[TradeZone]:
        """Extract active Order Block and FVG zones from the Middle Timeframe."""
        zones: List[TradeZone] = []

        # Order Blocks
        obs = mtf_signals.active_order_blocks
        if not obs.empty and "Top" in obs.columns and "Bottom" in obs.columns:
            for _, row in obs.iterrows():
                ob_val = row.get("OB", 0)
                top_val = row.get("Top")
                bottom_val = row.get("Bottom")
                if pd.isna(ob_val) or pd.isna(top_val) or pd.isna(bottom_val):
                    continue
                zones.append(
                    TradeZone(
                        zone_type="OB",
                        direction=int(ob_val),
                        top=float(top_val),
                        bottom=float(bottom_val),
                        timeframe=timeframe,
                        strength=float(row.get("OBVolume", 1.0)) if pd.notna(row.get("OBVolume")) else 1.0,
                    )
                )

        # Fair Value Gaps
        fvgs = mtf_signals.active_fvg
        if not fvgs.empty and "Top" in fvgs.columns and "Bottom" in fvgs.columns:
            for _, row in fvgs.iterrows():
                fvg_val = row.get("FVG", 0)
                top_val = row.get("Top")
                bottom_val = row.get("Bottom")
                if pd.isna(fvg_val) or pd.isna(top_val) or pd.isna(bottom_val):
                    continue
                zones.append(
                    TradeZone(
                        zone_type="FVG",
                        direction=int(fvg_val),
                        top=float(top_val),
                        bottom=float(bottom_val),
                        timeframe=timeframe,
                    )
                )

        return zones

    def find_ltf_entry(
        self,
        ltf_signals: ICTSignals,
        bias: MarketBias,
        zones: List[TradeZone],
        current_price: float,
    ) -> Optional[EntryPoint]:
        """Search for a precise entry on the Lower Timeframe.

        Only looks for entries aligned with the HTF bias within
        identified MTF zones.
        """
        if bias == MarketBias.NEUTRAL:
            return None

        target_dir = 1 if bias == MarketBias.BULLISH else -1

        # Check if price is inside any zone aligned with the bias
        for zone in zones:
            if zone.direction != target_dir:
                continue
            if not zone.contains_price(current_price):
                continue

            # Confirm with LTF BOS in the same direction
            ltf_bos = ltf_signals.latest_bos
            if ltf_bos != target_dir:
                continue

            direction = (
                TradeDirection.LONG
                if bias == MarketBias.BULLISH
                else TradeDirection.SHORT
            )

            # SL beyond the zone, TP at 2:1 ratio
            if direction == TradeDirection.LONG:
                stop_loss = zone.bottom * 0.998  # small buffer below zone
                risk = current_price - stop_loss
                take_profit = current_price + risk * 2
            else:
                stop_loss = zone.top * 1.002
                risk = stop_loss - current_price
                take_profit = current_price - risk * 2

            return EntryPoint(
                direction=direction,
                price=current_price,
                stop_loss=stop_loss,
                take_profit=take_profit,
                zone=zone,
                timeframe=settings.LTF_TIMEFRAME,
            )

        return None

    def _calculate_confluence(
        self,
        htf: ICTSignals,
        mtf: ICTSignals,
        ltf: ICTSignals,
        bias: MarketBias,
    ) -> int:
        """Count how many ICT conditions align (0-6)."""
        score = 0
        target = 1 if bias == MarketBias.BULLISH else (-1 if bias == MarketBias.BEARISH else 0)
        if target == 0:
            return 0

        # 1. Market structure (HTF bias exists)
        if bias != MarketBias.NEUTRAL:
            score += 1

        # 2. Liquidity sweep detected on MTF
        try:
            if not mtf.liquidity.empty:
                liq = mtf.liquidity.get("Liquidity", pd.Series(dtype=float))
                swept = liq.dropna()
                if len(swept) > 0:
                    val = swept.iloc[-1]
                    if pd.notna(val) and int(val) == target:
                        score += 1
        except (ValueError, TypeError):
            pass

        # 3. Order Block present on MTF
        try:
            if not mtf.active_order_blocks.empty:
                ob_dirs = mtf.active_order_blocks.get("OB", pd.Series(dtype=float))
                valid_obs = ob_dirs.dropna()
                if (valid_obs == target).any():
                    score += 1
        except (ValueError, TypeError):
            pass

        # 4. FVG present on MTF
        try:
            if not mtf.active_fvg.empty:
                fvg_dirs = mtf.active_fvg.get("FVG", pd.Series(dtype=float))
                valid_fvgs = fvg_dirs.dropna()
                if (valid_fvgs == target).any():
                    score += 1
        except (ValueError, TypeError):
            pass

        # 5. BOS on LTF
        if ltf.latest_bos is not None and ltf.latest_bos == target:
            score += 1

        # 6. CHOCH on MTF or LTF
        mtf_choch = mtf.latest_choch
        ltf_choch = ltf.latest_choch
        if (mtf_choch is not None and mtf_choch == target) or \
           (ltf_choch is not None and ltf_choch == target):
            score += 1

        return score