"""Minimal solver compiler for CatOpt Studio MVP.

This module provides a tiny, production-ready stub that translates the DSL
primitives (LocalProblem, SharedVariables) into a lightweight solver
configuration suitable for an ADMM-like, edge-friendly solver backend.

The goal here is to offer a stable, testable bridge between the DSL surface
and a real solver, without pulling in heavy dependencies or implementing a
full solver stack.
"""
from __future__ import annotations

from dataclasses import dataclass
from typing import Any, Dict, Optional

from .core import LocalProblem, SharedVariables


@dataclass
class SolverConfig:
    """Lightweight representation of a solver configuration.

    This is intentionally minimal and intended to be consumed by a real
    solver backend later. It captures a solver type and a few hyperparameters
    used by an ADMM-like routine.
    """

    solver_type: str
    rho: float
    max_iterations: int
    tolerance: float
    delta_sync: bool = False


def compile_to_solver(lp: LocalProblem, sv: SharedVariables, *, phase: int = 0) -> SolverConfig:
    """Translate a DSL LocalProblem into a SolverConfig.

    This is a lightweight heuristic intended for MVP demonstrations. The
    mapping is intentionally simple and deterministic to support deterministic
    replay during testing and islanding scenarios.
    """

    obj = (lp.objective or "").lower()
    domain = (lp.domain or "").lower()

    # Pick a solver flavor based on domain/objective hints
    if "energy" in domain:
        solver_type = "admm-lite-energy"
    elif "cost" in obj or "min" in obj:
        solver_type = "admm-lite-cost"
    else:
        solver_type = "admm-lite"

    # Simple heuristics for hyperparameters; keep things small and safe for
    # edge devices in MVP mode.
    rho = 1.0 if "energy" in domain else 0.5
    max_iterations = 50
    tolerance = 1e-4

    return SolverConfig(
        solver_type=solver_type,
        rho=float(rho),
        max_iterations=int(max_iterations),
        tolerance=float(tolerance),
        delta_sync=(phase > 0),
    )


def simulate_solver_step(
    config: SolverConfig, lp: LocalProblem, sv: SharedVariables, delta: Optional[Dict[str, Any]] = None
) -> Dict[str, Any]:
    """Emit a minimal, deterministic solver step result.

    This is a small helper to illustrate how a step might evolve given a
    configuration and current problem/variables. It does not perform any real
    optimization; it merely promotes structure for tests and demos.
    """

    # Produce a tiny, deterministic artifact that mirrors what a real step might
    # include (iteration index, delta, residual proxy).
    result: Dict[str, Any] = {
        "iteration": 1,
        "config": {
            "solver_type": config.solver_type,
            "rho": config.rho,
            "max_iterations": config.max_iterations,
            "tolerance": config.tolerance,
        },
        "delta_applied": delta or {},
        "primal_residual": max(0.0, 1.0 - float(config.rho)),
    }
    return result