config.ilp.solver="CPLEX"

butadien = Graph.fromGMLString(
"""graph [
     node [ id 0 label "C" ]
     node [ id 1 label "C" ]
     node [ id 2 label "C" ]
     node [ id 3 label "C" ]
     node [ id 4 label "H" ]
     node [ id 5 label "H" ]
     node [ id 6 label "H" ]
     node [ id 7 label "H" ]
     node [ id 8 label "H" ]
     node [ id 9 label "H" ]                                                                
     edge [ source 0 target 1 label "=" ]
     edge [ source 1 target 2 label "-" ]
     edge [ source 2 target 3 label "=" ]
     edge [ source 0 target 4 label "-" ]
     edge [ source 0 target 5 label "-" ]
     edge [ source 1 target 6 label "-" ]
     edge [ source 2 target 7 label "-" ]
     edge [ source 3 target 8 label "-" ]
     edge [ source 3 target 9 label "-" ]                                                        
]"""
, name="Butadien")

#allene = Graph.fromGMLString(
"""graph [
     node [ id 0 label "H" ]
     node [ id 1 label "H" ]
     node [ id 2 label "C" ]
     node [ id 3 label "C" ]
     node [ id 4 label "C" ]
     node [ id 5 label "H" ] 
     node [ id 6 label "H" ]                                                              
     edge [ source 0 target 2 label "" ]
     edge [ source 1 target 2 label "-" ]
     edge [ source 2 target 3 label "=" ]
     edge [ source 3 target 4 label "=" ]
     edge [ source 4 target 5 label "-" ]
     edge [ source 4 target 6 label "-" ]                                                       
]"""
#, name="Allene")

#pentadien = Graph.fromGMLString(
"""graph 
[
     node [ id 0 label "C" ]
     node [ id 1 label "C" ]
     node [ id 2 label "C" ]
     node [ id 3 label "C" ]
     node [ id 4 label "H" ]
     node [ id 5 label "H" ]
     node [ id 6 label "H" ]
     node [ id 7 label "H" ]
     node [ id 8 label "H" ]
     node [ id 9 label "C" ]     
     node [ id 10 label "H" ]    
     node [ id 11 label "H" ] 
     node [ id 12 label "H" ]       
     edge [ source 0 target 1 label "=" ]
     edge [ source 1 target 2 label "-" ]
     edge [ source 2 target 3 label "=" ]
     edge [ source 0 target 4 label "-" ]
     edge [ source 0 target 5 label "-" ]
     edge [ source 1 target 6 label "-" ]
     edge [ source 2 target 7 label "-" ]
     edge [ source 3 target 8 label "-" ]
     edge [ source 3 target 9 label "-" ]     
   edge [ source 9 target 10 label "-" ]    
   edge [ source 9 target 11 label "-" ] 
   edge [ source 9 target 12 label "-" ]                                                  
]
"""
#, name="Pentadien")

restswap = Rule.fromGMLString(
"""rule [
   left [
     edge [ source 1 target 2 label "=" ]
     edge [ source 3 target 4 label "=" ]
   ]
   context [
     node [ id 1 label "C" ]
     node [ id 2 label "C"]
     node [ id 3 label "C"]
     node [ id 4 label "C"]
   ]
   right [
     edge [ source 1 target 3 label "=" ]                                                                                                  
     edge [ source 2 target 4 label "=" ]                        
   ]
]"""
)

dielsalder = Rule.fromGMLString(
"""rule [
   left [
     edge [ source 1 target 2 label "=" ]
   edge [ source 2 target 3 label "-" ]
     edge [ source 3 target 4 label "=" ]
   edge [ source 5 target 6 label "=" ]
   
   ]
   context [
     node [ id 1 label "C" ]
     node [ id 2 label "C"]
     node [ id 3 label "C"]
     node [ id 4 label "C"]
   node [ id 5 label "C"]
   node [ id 6 label "C"]
   ]
   right [
     edge [ source 1 target 2 label "-" ]
   edge [ source 2 target 3 label "=" ]
     edge [ source 3 target 4 label "-" ]
   edge [ source 4 target 5 label "-" ]
   edge [ source 5 target 6 label "-" ] 
   edge [ source 6 target 1 label "-" ]                      
   ]
]"""
)

#MCB? horton vs DePina, einfach Depth first ob nach vier cyclus
def cyclesizes(g):
  cycles = []
  for edge, vertice in g.edges, g.vertices:
    print(dir(edge))
  #Find all cycles and list their sizes
  #Only for C
  #Chordless, elemenatary
  #Is there a inbuild way to ignore all H?
  #
  if min(cycles) < 5 or max(cycles) > 7:
    return True
  return False

#Disallows Allenes (Two Doublebonds on same carbon)
def doubledoublebond(g):
  for vertice in g.vertices:
    if (vertice.stringLabel == "C" and vertice.degree == 2): # and vertice.edges.label == ["=", "="] 
      for edge in vertice.incidentEdges:
        print(type(edge.bondType)) 
      bonds = [type(edge.bondType) for edge in vertice.incidentEdges]
      if (bonds[0] == bonds[1] and len(bonds) == 2):
        return True
  return False


def restriction(dg):
   #Only rings 5 to 7
   #No neighbouring double bonds. Is this already in MOD? Can this even happen?
   #No Carbon in 3 rings? Better 4?
   for a in dg.right:
      if a.vLabelCount("C") > 6:
         return False
      if doubledoublebond(a):
        return False
      #if cyclesizes(a):
         #return False
   return True

flowPrinter = FlowPrinter()
flowPrinter.printUnfiltered = False

postSection("Loaded Graphs")
for a in inputGraphs:
  a.print()
postSection("Loaded Rules")
for a in inputRules:
  a.print()


dg = DG(graphDatabase=inputGraphs)
dg.build().execute(
  addSubset(inputGraphs)
  >> rightPredicate[
    restriction
  ](
    repeat(revive(inputRules)) #Revive not necessary
  )

)
dg.print()
postSection("Product Graphs")
for a in dg.vertices:
  a.graph.print()

#flow = Flow(dg)
#flow.addSource(butadien)
#flow.findSolutions()
#flow.solutions.list()
#flow.solutions.print(flowPrinter)


sys.exit(0)

rc = rcEvaluator(inputRules)
for dRef in dg.derivations:
  der = dRef.derivation
  educt = rcId(der.left[0])
  for i in range(1, len(der.left)):
    educt = educt *rcParallel* rcId(der.left[i])
  product = rcId(der.right[0])
  for i in range(1, len(der.right)):
    product = product *rcParallel* rcId(der.right[i])
  rcExp = educt *rcSuper(allowPartial=False)* der.rule *rcSuper(allowPartial=False)* product
  res = rc.eval(rcExp)
  dRef.print()
  for a in res:
    a.print()
    a.printGML()