"""Rational labelled hidden-state sources with bounded integer branch clocks."""
from dataclasses import dataclass
from fractions import Fraction as Q
from math import lcm
from .arithmetic import Field, positive_int


@dataclass(frozen=True)
class Edge:
    start: int
    end: int
    digit: tuple
    clock: int
    probability: Q


class Source:
    def __init__(self,field:Field,states:int,edges,initial):
        self.field=field
        self.states=positive_int(states,"states")
        converted=[]
        for e in edges:
            if not isinstance(e,Edge):
                e=Edge(*e)
            if (isinstance(e.start,bool) or isinstance(e.end,bool) or
                not isinstance(e.start,int) or not isinstance(e.end,int) or
                not 0<=e.start<states or not 0<=e.end<states):
                raise ValueError("edge endpoint outside hidden-state range")
            positive_int(e.clock,"clock")
            p=Q(e.probability)
            if p<0 or p>1:
                raise ValueError("edge probabilities must lie in [0,1]")
            if p:
                converted.append(Edge(e.start,e.end,field.digit(e.digit),e.clock,p))
        self.edges=tuple(converted)
        self.outgoing=tuple(tuple(i for i,e in enumerate(self.edges) if e.start==s)
                            for s in range(states))
        if any(sum((self.edges[i].probability for i in ids),Q(0))!=1 for ids in self.outgoing):
            raise ValueError("outgoing edge probabilities must sum to one at every state")
        self.initial=tuple(map(Q,initial))
        if len(self.initial)!=states or min(self.initial)<=0 or sum(self.initial)!=1:
            raise ValueError("initial probabilities must be positive and sum to one; remove inactive states")
        self.transition=tuple(tuple(sum((e.probability for e in self.edges if e.start==i and e.end==j),Q(0))
                              for j in range(states)) for i in range(states))
        after=tuple(sum((self.initial[i]*self.transition[i][j] for i in range(states)),Q(0))
                    for j in range(states))
        self.stationary=(after==self.initial)
        self.digits=tuple(set(e.digit for e in self.edges))
        self.clocks=tuple(e.clock for e in self.edges)
        self.kmin,self.kmax=min(self.clocks),max(self.clocks)
        self.denominator=lcm(*(e.probability.denominator for e in self.edges))
        self.integer_weights=tuple(int(e.probability*self.denominator) for e in self.edges)

    def split_bound(self,n):
        return self.field.split_bound(n,self.digits,self.clocks)

    def slot_successors(self,slot,completed,n):
        """(position,remaining): a ready vertex, or a busy edge countdown."""
        position,remaining=slot
        if remaining:
            e=self.edges[position]
            if remaining==1:
                return (((e.end,0),completed+1,e.digit,Q(1)),)
            return (((position,remaining-1),completed,self.field.zero,Q(1)),)
        if completed>=n:
            return ()
        ans=[]
        for index in self.outgoing[position]:
            e=self.edges[index]
            if e.clock==1:
                ans.append(((e.end,0),completed+1,e.digit,e.probability))
            else:
                ans.append(((index,e.clock-1),completed,self.field.zero,e.probability))
        return tuple(ans)

    def sample_path(self,n,rng):
        positive_int(n,"depth")
        state=categorical(self.initial,rng)
        start=state
        path=[]
        for _ in range(n):
            ids=self.outgoing[state]
            j=categorical(tuple(self.edges[i].probability for i in ids),rng)
            index=ids[j]
            path.append(index)
            state=self.edges[index].end
        return start,tuple(path),state

    def path_map(self,path):
        u=self.field.zero
        clock=0
        units=[]
        for i in path:
            if isinstance(i,bool) or not isinstance(i,int) or not 0<=i<len(self.edges):
                raise ValueError("invalid edge index")
            e=self.edges[i]
            u=self.field.jump(u,e.clock,e.digit)
            clock+=e.clock
            units.extend([self.field.zero]*(e.clock-1))
            units.append(e.digit)
        return (clock,u),tuple(units)


def categorical(probabilities,rng):
    denominator=lcm(*(p.denominator for p in probabilities))
    r=rng.randrange(denominator)
    if isinstance(r,bool) or not isinstance(r,int) or not 0<=r<denominator:
        raise ValueError("random integer oracle violated its contract")
    total=0
    for i,p in enumerate(probabilities):
        total+=int(p*denominator)
        if r<total:
            return i
    raise ArithmeticError("invalid categorical source")