#!/usr/bin/env python3
"""Exact utility-dominant collapse, including Markov memory.

Tail optimization, collision-envelope certificates, and an exact arithmetic
inverse-CDF generator. Every validity calculation uses fractions. The random
bit generator in tests is reproducible, not cryptographic.
"""
from __future__ import annotations
from fractions import Fraction as F
from bisect import bisect_right
from dataclasses import dataclass
from certified_compiler import rational,Task,BitSource,pack_fraction


@dataclass(frozen=True)
class MarkovSource:
    initial:tuple[F,...]
    transition:tuple[tuple[F,...],...]
    useful:tuple[int,...]
    def __post_init__(self):
        pi=tuple(rational(v) for v in self.initial)
        P=tuple(tuple(rational(v) for v in row) for row in self.transition)
        h=tuple(self.useful)
        d=len(pi)
        if d<2 or min(pi)<=0 or sum(pi)!=1 or len(P)!=d or any(len(row)!=d or min(row)<=0 or sum(row)!=1 for row in P):
            raise ValueError('Full-support initial vector and stochastic transition matrix required.')
        if len(h)!=d or any(isinstance(v,bool) or not isinstance(v,int) or v not in (0,1) for v in h) or not 0<sum(h)<d:
            raise ValueError('A nonconstant binary useful-symbol map is required.')
        object.__setattr__(self,'initial',pi);object.__setattr__(self,'transition',P);object.__setattr__(self,'useful',h)
    @property
    def d(self):return len(self.initial)
    def probability(self,word):
        word=tuple(word)
        if not word or any(isinstance(a,bool) or not isinstance(a,int) or not 0<=a<self.d for a in word):
            raise ValueError('Invalid word.')
        value=self.initial[word[0]]
        for a,b in zip(word,word[1:]):value*=self.transition[a][b]
        return value


def count_law(source:MarkovSource,n:int):
    if isinstance(n,bool) or not isinstance(n,int) or n<1:raise ValueError('Positive integer depth required.')
    d=source.d
    v=[[F(0) for _ in range(d)] for _ in range(n+1)]
    for a,p in enumerate(source.initial):v[source.useful[a]][a]+=p
    for i in range(1,n):
        nxt=[[F(0) for _ in range(d)] for _ in range(n+1)]
        for j in range(i+1):
            for a in range(d):
                if not v[j][a]:continue
                for b in range(d):nxt[j+source.useful[b]][b]+=v[j][a]*source.transition[a][b]
        v=nxt
    result=tuple(sum(row,F(0)) for row in v)
    if sum(result)!=1:raise ArithmeticError('Count law failed normalization.')
    return result


def optimal_tail(probabilities,target):
    """Maximize retained mass under retained EXPECTED count >= target.

    Returns a scalar-count acceptance rule and an exact source-only LP dual.
    The source can be arbitrary: only its exact count distribution is used.
    """
    p=tuple(rational(v) for v in probabilities);t=rational(target)
    n=len(p)-1
    if n<1 or min(p)<0 or sum(p)!=1 or not 0<=t<=n:
        raise ValueError('Invalid count distribution or target.')
    if sum((j*v for j,v in enumerate(p)),F(0))>=t:
        return {'acceptance':tuple(F(1) for _ in p),'mass':F(1),'cut':None,'fraction':F(1),'eta_count':F(0),'target_count':t}
    acceptance=[F(0) for _ in p]
    slack=F(0)
    eta=None;cut=None;fraction=None
    for j in reversed(range(n+1)):
        b=F(j)-t
        if b<0 and slack+b*p[j]<0:
            fraction=slack/(-b*p[j])
            acceptance[j]=fraction
            eta=1/(-b);cut=j
            break
        acceptance[j]=1
        slack+=b*p[j]
    if eta is None:raise ArithmeticError('Tail boundary not found.')
    mass=sum((v*a for v,a in zip(p,acceptance)),F(0))
    utility=sum((v*a*(j-t) for j,(v,a) in enumerate(zip(p,acceptance))),F(0))
    dual=sum((v*max(F(0),1+eta*(j-t)) for j,v in enumerate(p)),F(0))
    if utility!=0 or mass!=dual:raise ArithmeticError('Tail primal/dual equality failed.')
    return {'acceptance':tuple(acceptance),'mass':mass,'cut':cut,'fraction':fraction,'eta_count':eta,'target_count':t}


def envelope_constant(acceptance,z):
    z=rational(z)
    if z<1:raise ValueError('Tilt z >= 1 required.')
    return max((rational(a)/z**j for j,a in enumerate(acceptance)),default=F(0))


def tilted_collision(source:MarkovSource,task:Task,n:int,z):
    """Exact b^n times squared output mass of mu(w) z^J(w).

    Synchronized pair recursion, using P^T V P in O(n d^3) arithmetic.
    This includes temporal dependencies, not just one-letter marginals.
    """
    z=rational(z);d=source.d;P=source.transition;h=source.useful
    if len(task.mapping)!=d or n<1 or z<=0:raise ValueError('Invalid collision parameters.')
    V=[[source.initial[a]*source.initial[b]*z**(h[a]+h[b]) if task.mapping[a]==task.mapping[b] else F(0)
        for b in range(d)] for a in range(d)]
    for _ in range(n-1):
        W=[[sum((V[a][b]*P[b][e] for b in range(d)),F(0)) for e in range(d)] for a in range(d)]
        V=[[z**(h[c]+h[e])*sum((P[a][c]*W[a][e] for a in range(d)),F(0)) if task.mapping[c]==task.mapping[e] else F(0)
            for e in range(d)] for c in range(d)]
    return task.base**n*sum((sum(row,F(0)) for row in V),F(0))


def collapse_certificate(source:MarkovSource,tasks,n:int,threshold,z=F(5)):
    gamma=rational(threshold);z=rational(z)
    if not 0<=gamma<=1:raise ValueError('Frequency threshold in [0,1] required.')
    counts=count_law(source,n)
    tail=optimal_tail(counts,n*gamma)
    C=envelope_constant(tail['acceptance'],z)
    bounds=tuple(C*C*tilted_collision(source,t,n,z) for t in tasks)
    return {'depth':n,'threshold':gamma,'count_law':counts,**tail,'tilt':z,'envelope_constant':C,
            'collision_upper_bounds':bounds,'collapse_proved':all(v<=1 for v in bounds),
            'optimal_expected_source_proposals':1/tail['mass'] if tail['mass'] else None}


class TailGenerator:
    """Finite-horizon Doob/conditional generator plus exact interval decoding.

    After O(n^2 d^2) exact arithmetic preprocessing, the emitted word law is
    Q(w) = mu(w) a[J(w)] / M. It consumes at most H_2(Q)+3 bits in expectation.
    That bound is an established interval-sampling principle, not a new code.
    Normalized Q does NOT automatically satisfy the original mass-one L2 bound.
    """
    def __init__(self,source:MarkovSource,n:int,acceptance):
        self.source=source;self.n=n
        self.acceptance=tuple(rational(v) for v in acceptance)
        if isinstance(n,bool) or not isinstance(n,int) or n<1 or len(self.acceptance)!=n+1 or any(not 0<=v<=1 for v in self.acceptance):
            raise ValueError('Invalid horizon or acceptance vector.')
        d=source.d
        # H[i][j][a] = expected terminal acceptance with i positions seen,
        # current useful count j, and current state a. All 0<=j<=i included.
        H=[None]*(n+1)
        H[n]=[[self.acceptance[j] for _ in range(d)] for j in range(n+1)]
        for i in reversed(range(1,n)):
            H[i]=[[sum((source.transition[a][b]*H[i+1][j+source.useful[b]][b] for b in range(d)),F(0))
                   for a in range(d)] for j in range(i+1)]
        self.H=H
        self.mass=sum((source.initial[a]*H[1][source.useful[a]][a] for a in range(d)),F(0))
        if self.mass<=0:raise ValueError('Accepted law has zero mass.')

    def conditional(self,prefix):
        i=len(prefix);s=self.source
        if not 0<=i<self.n:raise ValueError('Prefix length outside valid range.')
        j=sum(s.useful[a] for a in prefix)
        return self._conditional(i,j,prefix[-1] if prefix else None)

    def _conditional(self,i,j,a):
        s=self.source
        if i==0:
            values=tuple(s.initial[b]*self.H[1][s.useful[b]][b]/self.mass for b in range(s.d))
        else:
            den=self.H[i][j][a]
            if den<=0:raise ValueError('Zero-probability prefix.')
            values=tuple(s.transition[a][b]*self.H[i+1][j+s.useful[b]][b]/den for b in range(s.d))
        if sum(values)!=1:raise ArithmeticError('Conditional probabilities do not sum to one.')
        return values

    def draw(self,bits:BitSource):
        """A single global dyadic interval is reused over the entire word."""
        s=self.source
        prefix=[];L=F(0);R=F(1);integer=0;denom=1;count=0;state=None
        for i in range(self.n):
            q=self._conditional(i,count,state)
            labels=[];ends=[];running=L
            for b,v in enumerate(q):
                if v:
                    running+=(R-L)*v
                    labels.append(b);ends.append(running)
            if running!=R:raise ArithmeticError('Arithmetic interval failed normalization.')
            while True:
                left,right=F(integer,denom),F(integer+1,denom)
                k=bisect_right(ends,left)
                if k<len(ends) and right<=ends[k]:
                    newL=L if k==0 else ends[k-1]
                    L,R=newL,ends[k]
                    state=labels[k];count+=s.useful[state]
                    prefix.append(state)
                    break
                integer=2*integer+bits.bit();denom*=2
        return tuple(prefix)

    def probability(self,word):
        if len(word)!=self.n:raise ValueError('Invalid word length.')
        j=sum(self.source.useful[a] for a in word)
        return self.source.probability(word)*self.acceptance[j]/self.mass


def fixture(stickiness=F(0)):
    rho=rational(stickiness)
    if not 0<=rho<1:raise ValueError('Stickiness in [0,1) required.')
    p=(F(7,16),F(4,16),F(4,16),F(1,16))
    P=tuple(tuple((1-rho)*p[b]+(rho if a==b else 0) for b in range(4)) for a in range(4))
    source=MarkovSource(p,P,(0,0,0,1))
    tasks=(Task('first coordinate',2,(0,1,0,1)),Task('second coordinate',2,(0,0,1,1)))
    return source,tasks


def main():
    import json,argparse,time
    from pathlib import Path
    ap=argparse.ArgumentParser();ap.add_argument('--depth',type=int,default=32)
    ap.add_argument('--stickiness',default='0');ap.add_argument('--threshold',default='1/4')
    args=ap.parse_args();source,tasks=fixture(F(args.stickiness));start=time.perf_counter()
    result=collapse_certificate(source,tasks,args.depth,F(args.threshold))
    result['source']={'initial':source.initial,'transition':source.transition,'useful':source.useful}
    result['tasks']=[{'name':t.name,'base':t.base,'mapping':t.mapping} for t in tasks]
    result['display']={'mass':float(result['mass']),'collision_upper_bounds':[float(v) for v in result['collision_upper_bounds']],
                       'expected_proposals':float(result['optimal_expected_source_proposals']),
                       'elapsed_seconds':time.perf_counter()-start}
    root=Path(__file__).resolve().parents[1]
    out=root/'results'/f'tail_n{args.depth}_rho{args.stickiness.replace("/","_")}.json'
    out.write_text(json.dumps(pack_fraction(result),indent=2)+'\n')
    print(json.dumps({'output':str(out),'collapse_proved':result['collapse_proved'],'cut':result['cut'],**result['display']},indent=2))

if __name__=='__main__':main()