from __future__ import annotations

import time
from typing import Dict, Any
from .core import LocalArbProblem, SharedSignals, PlanDelta


def _deterministic_delta(seed: str) -> float:
    basis = sum(ord(ch) for ch in seed)
    return 0.0002 * (basis % 5)


class PriceFeedAdapter:
    """Adapter A: emits LocalArbProblem + SharedSignals on a fixed cadence."""

    def __init__(self, venue: str, assets: list[str]):
        self.venue = venue
        self.assets = assets
        self.version = 1

    def step(self) -> tuple[LocalArbProblem, SharedSignals]:
        prob = LocalArbProblem(
            id=f"{self.venue}-p1",
            venue=self.venue,
            assets=self.assets,
            target_misprice=0.001,
            max_exposure=100000.0,
            latency_budget=0.1,
        )
        signals = SharedSignals(
            version=self.version,
            price_delta_by_asset={a: _deterministic_delta(f"{self.venue}:{a}") for a in self.assets},
            cross_corr={(a1, a2): 0.1 for a1 in self.assets for a2 in self.assets if a1 != a2},
            liquidity_estimates={a: 1.0 for a in self.assets},
        )
        self.version += 1
        return prob, signals


class BrokerAdapter:
    """Adapter B: consumes PlanDelta and prints a simulated fill."""

    def __init__(self, venue: str):
        self.venue = venue

    def execute(self, plan: PlanDelta) -> Dict[str, Any]:
        fills = []
        for action in plan.delta_actions:
            fills.append(
                {
                    "asset": action.get("asset"),
                    "size": action.get("size"),
                    "from": action.get("from_venue"),
                    "to": action.get("to_venue"),
                    "status": "filled",
                    "fee_bps": 1.0,
                }
            )
        return {
            "venue": self.venue,
            "timestamp": plan.timestamp,
            "fills": fills,
            "ack": True,
            "contract_id": plan.contract_id,
            "signature": plan.signature,
        }