import snakes.plugins
snakes.plugins.load(['gv', 'ops'], 'snakes.nets', 'nets')
from nets import *



###############################################################################
###############################################################################
############################### INIT ##########################################

# entities: tuple of name of the entities, initial level, tuple of decays 0
# denotes unbounded decay (omega)
#entities = ( ('B',4, (0,2,2,2,3)), ('P',0, (0,0)), ('C',0, (0,0)), ('G',0, (0,0)))


#entities = ( ('Sugar',1, (0,2)), ('Aspartame',0, (0,2)), ('Glycemia',2, (0,2,2,2)), ('Glucagon',0, (0,2)), ('Insulin',0,(0,2,2)))


entities = ( ('s1',0, (0,1)), ('s2',0, (0,1)), ('s3',0, (0,1)) )



# Activities: Tuple of (activators, inhibitors, results, duration)
# activators, inhibitors are dictionaries of pairs (entity, level)
# results are dictionaries of pairs (entity, +z)

# potential activities
#potential = ((dict([('P',0)]),dict([('P',1)]),dict([('P',1)]),0),
#             (dict([('P',1)]),dict(),dict([('P',-1)]),0),
#             (dict([('C',0)]),dict([('C',1)]),dict([('C',1)]),0),
#             (dict([('C',1)]),dict(),dict([('C',-1)]),0),
#             (dict([('G',0)]),dict([('G',1)]),dict([('G',1)]),0),
#             (dict([('G',1)]),dict(),dict([('G',-1)]),0) )

# potential = ((dict([('Sugar',1)]),dict(),dict([('Insulin',1),('Glycemia',1)]),0),
#              (dict([('Aspartame',1)]),dict(),dict([('Insulin',1)]),0),
#              (dict(),dict([('Glycemia',1)]),dict([('Glucagon',1)]),0),
#              (dict([('Glycemia',3)]),dict(),dict([('Insulin',1)]),0),
#              (dict([('Insulin',2)]),dict(),dict([('Glycemia',-1)]),0),
#              (dict([('Insulin',1),('Glycemia',3)]), dict(), dict([('Glycemia',-1)]),0),
#              (dict([('Insulin',1)]),dict([('Glycemia',2)]),dict([('Glycemia',-1)]),0),
#              (dict([('Glucagon',1)]),dict(),dict([('Glycemia',+1)]),0) )

potential = ( (dict(),dict([('s1',1)]),dict([('s2',1)]), 1),
              (dict(),dict([('s2',1)]),dict([('s3',1)]), 1),
              (dict(),dict([('s3',1)]),dict([('s1',1)]), 1) )



# obligatory activities
#obligatory = ( (dict([('P',1)]),dict(),dict([('B',1)]),1),
#               (dict([('C',1)]),dict(),dict([('B',-1)]),3),
#               (dict([('G',1)]),dict(),dict([('B',-2)]),3))

obligatory = ()
###############################  END ##########################################
###############################################################################
###############################################################################


###############################################################################
###############################################################################
############################ AUXILIARY FUNCTIONS ##############################

# This function computes the action of clock + decay + obligatory activities
# obligatory = set of obligatory activities
# name = entity concerned
# ls = ls of entity
# us = us of entity
# lambdas = lambdas of entity
# deltas = list of the decays duration of entity
# inputlist = tuples for all other entities
def clockt (obligatory, name, ls, us, lambdas, deltas, inputlist,D) :


    print (obligatory, name, ls, us, lambdas, deltas, inputlist,D)
    l1=ls
    u1=us
    lambda1=[]

    # progression of time in lambda
    for i in range(0,len(lambdas)): lambda1.append(min(lambdas[i]+1, D))

    # progression of time for u (only for bounded levels)
    if deltas[ls] <> 0 : u1=us+1

    # decay
    if us+1 > deltas[ls] :
        l1 = max(0, ls -1)
        u1 = 0

    # search of obligatory activities where entity name is in results
    act = []
    for alpha in range(0, len(obligatory)) :
        obname = 'ob'+str(alpha)
        if name in obligatory[alpha][2] and inputlist[obname]>= obligatory[alpha][3]:
            act.append(obligatory[alpha])



    # computation of the effect on entity name
    for alpha in range(0, len(act)) :
        # check if the obligatory activity is enabled or not
        check = 0
        activators = act[alpha][0]
        for ent in activators :
            t = inputlist[ent]
            if t[0] >= activators[ent] and t[2][activators[ent]] >= act[alpha][3] : check = 1
        inhibitors = act[alpha][1]
        for ent in inhibitors :
            t = inputlist[ent]
            if t[0] < inhibitors[ent] and t[2][inhibitors[ent]] >= act[alpha][3] : check = 1
        # if enabled compute the effect
        if check :
            z = act[alpha][2][name]
            l1 = max(0, min(l1 + z, len(lambda1)-1))
            u1 = 0

    # update lambda with the proper dates
    temp = l1 - ls
    if temp > 0 :
        for i in range(ls+1,l1) : lambda1[i]=0
    if temp < 0 :
        for i in range(l1+1,ls) : lambda1[i]=0

    return (l1, u1, tuple(lambda1))


# This function computes the action of clock on obligatory activities places
# obligatory = set of obligatory activities
# name = obligatory activity under consideration
# w = current value
# inputlist = tuples for all other entities
def clockbetat (obligatory, name, w, inputlist,D) :
    check = 0
    activators = obligatory[name][0]
    for ent in activators :
        t = inputlist[ent]
        if t[0] >= activators[ent] and t[2][activators[ent]] >= obligatory[name][3] : check = 1
    inhibitors = obligatory[name][1]
    for ent in inhibitors :
        t = inputlist[ent]
        if t[0] < inhibitors[ent] and t[2][inhibitors[ent]] >= obligatory[name][3] : check = 1
        # if enabled compute the effect
    if check and w >= obligatory[name][3] : return(0)
    else: return(min(w+1, D))





# this function computes the action on an entity of a potential activity
# name = entity under consideration
# lp, up, lambdap = its values
# R = set of results of the activity
def potentialt (name, lp, up, lambdap, R) :
    print (name, lp, up, lambdap, R)
    # entity is a result?
    if (name in R) :
        lambda2 = list(lambdap)
        levelp = max(0,min(len(lambdap)-1, lp+R[name]))
        change = levelp-lp
        if  change > 0 :
            for i in range(lp+1,levelp+1):
                lambda2[i]=0
        if  change < 0 :
            for i in range(levelp+1,lp+1):
                lambda2[i]=0
        return (levelp, 0,tuple(lambda2))
    else:
        return (lp, up, lambdap)

##############################     END     ####################################
###############################################################################
###############################################################################


####################### MAIN ##################################################

# compute maximal duration of activities
D=0
for alpha in potential : D = max(D, alpha[3])

for alpha in obligatory : D = max(D, alpha[3])

n = PetriNet('andy')

n.globals["obligatory"] = obligatory
n.globals["D"] = D
n.globals["clockt"] = clockt
n.globals["clockbetat"] = clockbetat
n.globals["potentialt"] = potentialt

################# Places for entities
for i in range(0,len(entities)):
    name=entities[i][0]
    level = entities[i][1]
    deltas = entities[i][2]
    vector = [0]*len(deltas)
    n.add_place(Place(name, [(level,0, tuple(vector))]))

################# clock transition
inputlist = dict()
n.globals["inputlist"] = inputlist

n.add_transition(Transition('tc'))


# connect all obligatory clocks
for i in range(0,len(obligatory)):
    # transition name
    obname = 'ob'+str(i)
    # for every obligatory activity connect corresponding place to clock
    n.add_place(Place('p'+obname, [0]))
    n.add_input('p'+obname, 'tc', Variable('w'+obname))
    inputlist.update({obname:'w'+obname})


# all entities are connected
for i in range(0,len(entities)):
    name=entities[i][0]
    deltas = entities[i][2]
    n.globals["deltas"+name] = deltas
    n.globals[name] = name
    n.add_input(name, 'tc', Tuple([Variable('l'+name), Variable('u'+name), Variable('lambda'+name) ]))
    inputlist.update({name:['l'+name, 'u'+name, 'lambda'+name ]})



for i in range(0,len(entities)):
    name=entities[i][0]
    n.add_output(name, 'tc', Expression("clockt(obligatory,"+name+",l"+name+',u'+name+',lambda'+name+',deltas'+name+',inputlist,D)'))


for i in range(0,len(obligatory)):
    obname = 'ob'+str(i)
    # for every obligatory activity connect corresponding place to clock
    n.add_output('p'+obname, 'tc', Expression("clockbetat(obligatory,"+str(i)+',w'+obname+',inputlist,D)'))


## potential activities
for i in range(0,len(potential)):
    # transition name
    trname = 'tr'+str(i)

    # for every potential activity connect corresponding place to clock
    n.add_place(Place('p'+trname, [0]))
    n.add_input('p'+trname, 'tc', Variable('w'+trname))
    n.add_output('p'+trname, 'tc', Expression('min(D,w'+trname+'+1)'))


    activators = potential[i][0]
    inhibitors = potential[i][1]
    results = potential[i][2]
    print results
    n.globals["results"+trname] = results
    duration = potential[i][3]

    # compute entities involved in the activity
    nameactivators = activators.keys()
    nameinhib = inhibitors.keys()
    nameresults = results.keys()
    names = []
    # check they appear only once
    for i in nameactivators : names.append(i)
    for i in nameinhib:
        if not (i in activators) : names.append(i)
    for i in nameresults:
        if not ( (i in activators) or (i in inhibitors)) : names.append(i)

    # compute guard of the activity
    # activity may be executed once every dur
    guard = 'w>='+str(duration)

    # activators
    for j in range(0,len(nameactivators)) :
        spec = nameactivators[j]
        level = str(activators[nameactivators[j]])
        guard += ' and l'+spec+'>= '+ level + ' and lambda' +spec+'['+level+']>='+str(duration)

    # inhibitors
    for j in range(0,len(nameinhib)) :
        spec = nameinhib[j]
        level = str(inhibitors[nameinhib[j]])
        guard += ' and l'+spec+'< '+ level + ' and lambda' +spec+'['+level+']>='+str(duration)

    n.add_transition(Transition(trname, Expression(guard)))
    n.add_input('p'+trname, trname, Variable('w'))
    n.add_output('p'+trname, trname, Expression('0'))

    # arcs of the transition from and to involved entities
    for j in range(0,len(names)) :
        n.add_input(names[j], trname, Tuple([Variable('l'+names[j]), Variable('u'+names[j]), Variable('lambda'+names[j]) ]))
        n.add_output(names[j], trname, Expression("potentialt(" +names[j]+",l"+names[j]+',u'+names[j]+',lambda'+names[j]+', results'+trname+')'))



######## depict Petri net
n.draw("repress.ps")

s = StateGraph(n)
s.build()

def node_attr (state, graph, attr) :
    # attr['label'] = str(state)
    marking = graph[state]
    attr["label"] = ":".join(str(list(marking(s))[0][0])
                             for s in ("s1", "s2", "s3"))

def edge_attr (trans, mode, attr) :
    attr["label"] = trans.name

s.draw('repressgraph.ps', node_attr=node_attr, edge_attr=edge_attr,
       engine="dot")

g = s.draw(None, node_attr=node_attr, edge_attr=edge_attr, engine="dot")
with open("repressgraph.dot", "w") as out :
    out.write(g.dot())

g.render("repressgraph-layout.dot", engine="dot")

# t=n.transition('tr0')
# m=t.modes()
# print m
# t.fire(m[0])
# n.draw('repr1.ps')
# t1=n.transition('tc')
# m1=t1.modes()
# print m1
# t1.fire(m1[0])
# n.draw('repr1.ps')