"""Runs the complete analysis pipeline for one SKU.

SKU -> SkuAnalyzer -> FreightAnalyzer -> PricingAnalyzer -> InventoryAnalyzer
    -> ShippingAnalyzer -> ProfitAnalyzer -> SkuScoreCalculator -> SkuDecision
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Optional

from .freight_analyzer import FreightAnalysis, FreightAnalyzer
from .inventory_analyzer import InventoryAnalysis, InventoryAnalyzer
from .pricing_analyzer import PricingAnalyzer, PricingResult
from .profit_analyzer import ProfitAnalysis, ProfitAnalyzer
from .shipping_analyzer import ShippingAnalysis, ShippingAnalyzer
from .sku_analyzer import SkuAnalyzer, SkuInfo
from .sku_score_calculator import SkuScore, SkuScoreCalculator


@dataclass
class SkuDecision:
    """Everything the engine knows about a single SKU."""

    sku: SkuInfo
    freight: FreightAnalysis
    pricing: PricingResult
    inventory: InventoryAnalysis
    shipping: ShippingAnalysis
    profit: ProfitAnalysis
    result: SkuScore

    def to_dict(self) -> dict:
        return {
            "sku": self.sku.to_dict(),
            "freight": self.freight.to_dict(),
            "pricing": self.pricing.to_dict(),
            "inventory": self.inventory.to_dict(),
            "shipping": self.shipping.to_dict(),
            "profit": self.profit.to_dict(),
            "score": self.result.to_dict(),
        }


class SkuDecisionEngine:
    """Single responsibility: coordinate the SKU analyzers in order."""

    def __init__(self) -> None:
        self._sku_analyzer = SkuAnalyzer()
        self._freight_analyzer = FreightAnalyzer()
        self._pricing_analyzer = PricingAnalyzer()
        self._inventory_analyzer = InventoryAnalyzer()
        self._shipping_analyzer = ShippingAnalyzer()
        self._profit_analyzer = ProfitAnalyzer()
        self._score_calculator = SkuScoreCalculator()

    def analyze(
        self,
        sku_dto: dict,
        freight_json: Optional[dict],
        profit_margin: float,
        popularity_score: float,
        store_score: float,
        max_supplier_price: float,
    ) -> SkuDecision:
        sku = self._sku_analyzer.analyze(sku_dto)
        freight = self._freight_analyzer.analyze(freight_json)
        pricing = self._pricing_analyzer.analyze(
            supplier_price=sku.supplier_price,
            shipping_price=freight.shipping_cost,
            profit_margin=profit_margin,
        )
        inventory = self._inventory_analyzer.analyze(sku.stock)
        shipping = self._shipping_analyzer.analyze(freight)
        profit = self._profit_analyzer.analyze(
            pricing, market_reference_price=sku.sale_price
        )
        result = self._score_calculator.calculate(
            sku=sku,
            freight=freight,
            shipping=shipping,
            inventory=inventory,
            profit=profit,
            popularity_score=popularity_score,
            store_score=store_score,
            max_supplier_price=max_supplier_price,
        )
        return SkuDecision(
            sku=sku,
            freight=freight,
            pricing=pricing,
            inventory=inventory,
            shipping=shipping,
            profit=profit,
            result=result,
        )