"""Fixed-period, fixed-mean exact-formula optimizer (floating-point evaluator).

The proofs cover measurable controls. This code evaluates their finite formulas;
it does not certify signs/ties extremely near resonance or supply interval proofs.
"""
from __future__ import annotations
from dataclasses import dataclass
import math
import numpy as np
from floquet import transfer, phase_speed

@dataclass(frozen=True)
class ResourceCandidate:
    winding: int
    high_time: float
    low_time: float
    discriminant: float
    log_gain: float


def resource_optimum(R: float, S: float, mean: float) -> tuple[float, list[ResourceCandidate]]:
    if not all(map(math.isfinite, (R,S,mean))) or R <= 1 or S <= 0:
        raise ValueError('Require finite R > 1, S > 0 and mean in [1,R^2].')
    B = R*R
    if not 1 <= mean <= B:
        raise ValueError('Mean is outside the material interval.')
    if mean in (1.0,B):
        return 0.0, []
    duty = (mean-1)/(B-1)
    candidates = []
    for n in range(1, math.floor(R*S/math.pi)+1):
        tau = S/n
        if not math.pi/R < tau < math.pi:
            continue
        h,ell = duty*tau,(1-duty)*tau
        if R*h >= math.pi or ell >= math.pi:
            continue
        D = math.cos(R*h)*math.cos(ell) - (R+1/R)/2*math.sin(R*h)*math.sin(ell)
        if D < -1:
            candidates.append(ResourceCandidate(n,h,ell,D,n*math.acosh(-D)))
    return max((c.log_gain for c in candidates),default=0.0),candidates


def lifted_phase_map(theta: float, w: float, inverse: bool=False) -> float:
    """Lift of atan(tan(theta)/w), or its inverse, modulo pi."""
    j = math.floor((theta+math.pi/2)/math.pi)
    x = theta-j*math.pi
    factor = w if inverse else 1/w
    return math.atan(factor*math.tan(x))+j*math.pi


def advance_phase(theta: float, u: float, duration: float) -> float:
    w = math.sqrt(u)
    return lifted_phase_map(lifted_phase_map(theta,w)+w*duration,w,True)


def dual_parameters(R: float, candidate: ResourceCandidate) -> tuple[float,float,float,float]:
    """Return eta, xi, high-arc start/end angles from the expanding eigenline.

    Assumes a strictly hyperbolic candidate; conditioning degrades at gap edges.
    """
    B = R*R
    P = transfer(1,candidate.low_time) @ transfer(B,candidate.high_time)
    vals,vecs = np.linalg.eig(P)
    x = np.real(vecs[:,int(np.argmax(np.abs(vals)))])
    theta0 = math.atan2(-x[1],x[0]) % math.pi
    theta1 = advance_phase(theta0,B,candidate.high_time)
    rows = np.array([[math.cos(t)**2,-math.sin(t)**2] for t in (theta0,theta1)])
    rhs = np.array([-math.sin(t)*math.cos(t) for t in (theta0,theta1)])
    eta,xi = np.linalg.solve(rows,rhs)
    if 1+4*eta*xi <= 0:
        raise ArithmeticError('Unresolved/nonhyperbolic switching discriminant.')
    return float(eta),float(xi),theta0,theta1


def switching(theta: float, eta: float, xi: float) -> float:
    c,s = math.cos(theta),math.sin(theta)
    return s*c+eta*c*c-xi*s*s


def selector(theta: float, R: float, eta: float, xi: float) -> float:
    return R*R if switching(theta,eta,xi)>0 else 1.0


def resource_defect(theta: float, u: float, R: float, eta: float, xi: float) -> float:
    b = selector(theta,R,eta,xi)
    return abs(switching(theta,eta,xi))*abs(u-b)/(phase_speed(theta,u)*phase_speed(theta,b))


def phase_stability_constant(R:float,candidate:ResourceCandidate) -> float:
    eta,xi,_,_ = dual_parameters(R,candidate)
    return 2*math.pi*R*R*math.sqrt(candidate.winding*(R*R-1))/(1+4*eta*xi)**0.25


def resource_gap_interval(R:float,mean:float)->tuple[float,float]:
    """Unique one-turn hyperbolic period interval (tau_minus,tau_plus)."""
    from scipy.optimize import brentq
    if not (R>1 and 1<mean<R*R):raise ValueError('Strict contrast and interior mean required.')
    p=(mean-1)/(R*R-1)
    end=min(math.pi/(R*p),math.pi/(1-p))
    def f(t):return math.tan(R*p*t/2)*math.tan((1-p)*t/2)
    hi=np.nextafter(end,0.)
    lo=brentq(lambda t:f(t)-1/R,0,hi,xtol=1e-13)
    up=brentq(lambda t:f(t)-R,0,hi,xtol=1e-13)
    return lo,up


def resource_free(R:float,mean:float)->ResourceCandidate:
    """Unique maximum of G(tau)/tau. Strict concavity proves uniqueness."""
    from scipy.optimize import brentq
    p=(mean-1)/(R*R-1)
    lo,hi=resource_gap_interval(R,mean)
    A=(R+1/R)/2
    def q(t):
        x,y=R*p*t,(1-p)*t
        D=math.cos(x)*math.cos(y)-A*math.sin(x)*math.sin(y)
        Dp=-R*p*math.sin(x)*math.cos(y)-(1-p)*math.cos(x)*math.sin(y) \
           -A*(R*p*math.cos(x)*math.sin(y)+(1-p)*math.sin(x)*math.cos(y))
        G=math.acosh(-D)
        Gp=-Dp/math.sqrt(D*D-1)
        return t*Gp-G
    cut=(hi-lo)*1e-8
    tau=brentq(q,lo+cut,hi-cut,xtol=1e-13)
    D=math.cos(R*p*tau)*math.cos((1-p)*tau)-A*math.sin(R*p*tau)*math.sin((1-p)*tau)
    return ResourceCandidate(1,p*tau,(1-p)*tau,D,math.acosh(-D))