#config.ilp.solver="CPLEX"
#import mod
#from mod import *
import networkx as nx

# import Graph class from graph.py
from graph import GraphObj

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")


#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 "-" ]                      
   ]
]"""
)

def cyclesizes(g):
  nxGraph = GraphObj(g).nx_graph

  #Chein restrictions: (No steric reason)
  paths = sorted(list(nx.all_simple_paths(nxGraph)))
  if max(paths > 12):
    return True
  
  #Cycle restrictions:
  cycles = sorted(list(nx.chordless_cycles(nxGraph)))
  cycle_lengths = [len(x) for x in cycles]
  if cycles == []:
    return False
  #One Atom can't be in four different cycles
  for vertice in nxGraph.nodes:
    counter = 0
    for cycle in cycles:
      if vertice in cycle:
        counter += 1
    if counter >= 4:
      return True
  #One Cycle can't overlapp with another on over 2 Connection points
  for cycle in cycles:
    for cycleref in cycles:
      if cycle != cycleref and len(list(set(cycle) & set(cycleref))) >= 3:
        return True
  #Only cordless cycles of length 5,6 and 7 are acceptable
  if min(cycle_lengths) >= 5 and max(cycle_lengths) <=7:
    return False
  return True

#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") > 10:
         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()