from __future__ import absolute_import, division, print_function

from boost_adaptbx import graph
from boost_adaptbx.graph import maximum_clique

import unittest

class accumulator(object):

  def __init__(self):

    self.largest = 0
    self.sent = []

  def __call__(self, result):

    size = len( result )

    if self.largest < size:
      self.largest = size
      self.sent = [ result ]

    elif self.largest == size:
      self.sent.append( result )


class TestRascal(unittest.TestCase):

  def manipulation(self, g):

    n = {}
    n[ "1,1'" ] = g.add_vertex() # 0
    n[ "1,5'" ] = g.add_vertex() # 1
    n[ "2,2'" ] = g.add_vertex() # 2
    n[ "2,3'" ] = g.add_vertex() # 3
    n[ "3,2'" ] = g.add_vertex() # 4
    n[ "3,3'" ] = g.add_vertex() # 5
    n[ "4,4'" ] = g.add_vertex() # 6
    n[ "5,1'" ] = g.add_vertex() # 7
    n[ "5,5'" ] = g.add_vertex() # 8

    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "3,3'" ] )
    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "3,2'" ] )
    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "3,3'" ] )
    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "2,3'" ], vertex2 = n[ "3,2'" ] )
    g.add_edge( vertex1 = n[ "2,3'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "3,2'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "3,3'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "3,3'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "4,4'" ], vertex2 = n[ "5,1'" ] )
    g.add_edge( vertex1 = n[ "4,4'" ], vertex2 = n[ "5,5'" ] )

    a = accumulator()
    maximum_clique.rascal( graph = g, callable = a )
    self.assertEqual(
      set(
        [
          frozenset( [ n[ "1,1'" ], n[ "3,3'" ] , n[ "4,4'" ], n[ "5,5'" ] ] ),
          frozenset( [ n[ "2,2'" ], n[ "3,3'" ] , n[ "4,4'" ], n[ "5,5'" ] ] ),
          ]
        ),
      set( frozenset( m ) for m in a.sent ),
      )


  def test_adjacency_list_undirected_vector_set(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_list_set(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_vector_vector(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_list_vector(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


class TestGreedy(unittest.TestCase):

  def manipulation(self, g):

    n = {}
    n[ "1,1'" ] = g.add_vertex() # 0
    n[ "1,5'" ] = g.add_vertex() # 1
    n[ "2,2'" ] = g.add_vertex() # 2
    n[ "2,3'" ] = g.add_vertex() # 3
    n[ "3,2'" ] = g.add_vertex() # 4
    n[ "3,3'" ] = g.add_vertex() # 5
    n[ "4,4'" ] = g.add_vertex() # 6
    n[ "5,1'" ] = g.add_vertex() # 7
    n[ "5,5'" ] = g.add_vertex() # 8

    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "3,3'" ] )
    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "3,2'" ] )
    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "3,3'" ] )
    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "2,3'" ], vertex2 = n[ "3,2'" ] )
    g.add_edge( vertex1 = n[ "2,3'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "3,2'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "3,3'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "3,3'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "4,4'" ], vertex2 = n[ "5,1'" ] )
    g.add_edge( vertex1 = n[ "4,4'" ], vertex2 = n[ "5,5'" ] )

    result = maximum_clique.greedy( graph = g )
    self.assertEqual(
      set(
        [
          frozenset( [ n[ "1,1'" ], n[ "3,3'" ] , n[ "4,4'" ], n[ "5,5'" ] ] ),
          frozenset( [ n[ "2,2'" ], n[ "3,3'" ] , n[ "4,4'" ], n[ "5,5'" ] ] ),
          ]
        ),
      set( frozenset( m ) for m in result ),
      )


  def test_adjacency_list_undirected_vector_set(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_list_set(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_vector_vector(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_list_vector(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


class TestCompatibilityGraph(unittest.TestCase):

  def manipulation(self, left, right):

    u1 = left.add_vertex( label = "O" )
    u2 = left.add_vertex( label = "C" )
    u3 = left.add_vertex( label = "C" )
    u4 = left.add_vertex( label = "N" )
    u5 = left.add_vertex( label = "O" )

    left.add_edge( vertex1 = u1, vertex2 = u2, weight = 1 )
    left.add_edge( vertex1 = u2, vertex2 = u3, weight = 1 )
    left.add_edge( vertex1 = u3, vertex2 = u4, weight = 1 )
    left.add_edge( vertex1 = u3, vertex2 = u5, weight = 2 )

    v1 = right.add_vertex( label = "O" )
    v2 = right.add_vertex( label = "C" )
    v3 = right.add_vertex( label = "C" )
    v4 = right.add_vertex( label = "N" )
    v5 = right.add_vertex( label = "O" )

    right.add_edge( vertex1 = v1, vertex2 = v2, weight = 2 )
    right.add_edge( vertex1 = v2, vertex2 = v3, weight = 1 )
    right.add_edge( vertex1 = v3, vertex2 = v4, weight = 1 )
    right.add_edge( vertex1 = v3, vertex2 = v5, weight = 2 )

    result = maximum_clique.compatibility_graph(
      first = left,
      second = right,
      )

    vertices = list( result.vertices() )
    edges = list( result.edges() )

    self.assertEqual( len( vertices ), 9 )
    self.assertEqual( len( edges ), 16 )

    self.assertEqual(
      set( result.vertex_label( vertex = v ) for v in result.vertices() ),
      set(
        [
          ( u1, v1 ), ( u1, v5 ), ( u5, v1 ), ( u5, v5 ),
          ( u2, v2 ), ( u2, v3 ), ( u3, v2 ), ( u3, v3 ),
          ( u4, v4 ),
          ]
        )
      )
    edges_between = set(
      [
        frozenset(
          [
            result.vertex_label( vertex = result.source( edge = e ) ),
            result.vertex_label( vertex = result.target( edge = e ) ),
            ]
          )
        for e in result.edges()
        ]
      )
    self.assertEqual(
      edges_between,
      set(
        [
          frozenset( [ ( u1, v1 ), ( u3, v3 ) ] ),
          frozenset( [ ( u1, v1 ), ( u4, v4 ) ] ),
          frozenset( [ ( u1, v1 ), ( u5, v5 ) ] ),

          frozenset( [ ( u1, v5 ), ( u3, v2 ) ] ),
          frozenset( [ ( u1, v5 ), ( u4, v4 ) ] ),
          frozenset( [ ( u1, v5 ), ( u5, v1 ) ] ),

          frozenset( [ ( u2, v2 ), ( u3, v3 ) ] ),
          frozenset( [ ( u2, v2 ), ( u4, v4 ) ] ),
          frozenset( [ ( u2, v2 ), ( u5, v5 ) ] ),

          frozenset( [ ( u2, v3 ), ( u3, v2 ) ] ),
          frozenset( [ ( u2, v3 ), ( u5, v1 ) ] ),

          frozenset( [ ( u3, v2 ), ( u5, v1 ) ] ),

          frozenset( [ ( u3, v3 ), ( u4, v4 ) ] ),
          frozenset( [ ( u3, v3 ), ( u5, v5 ) ] ),

          frozenset( [ ( u4, v4 ), ( u5, v1 ) ] ),
          frozenset( [ ( u4, v4 ), ( u5, v5 ) ] ),
          ]
        )
      )


  def test_adjacency_list_undirected_vector_set(self):

    try:
      g1 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "set",
        )
      g2 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( left = g1, right = g2 )


  def test_adjacency_list_undirected_list_set(self):

    try:
      g1 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "set",
        )
      g2 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( left = g1, right = g2 )


  def test_adjacency_list_undirected_vector_vector(self):

    try:
      g1 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "vector",
        )
      g2 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( left = g1, right = g2 )


  def test_adjacency_list_undirected_list_vector(self):

    try:
      g1 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "vector",
        )
      g2 = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( left = g1, right = g2 )


class TestSelectedSubgraph(unittest.TestCase):

  def manipulation(self, g):

    n = {}
    n[ "1,1'" ] = g.add_vertex( label = "1,1'" ) # 0
    n[ "1,5'" ] = g.add_vertex( label = "1,5'" ) # 1
    n[ "2,2'" ] = g.add_vertex( label = "2,2'" ) # 2
    n[ "2,3'" ] = g.add_vertex( label = "2,3'" ) # 3
    n[ "3,2'" ] = g.add_vertex( label = "3,2'" ) # 4
    n[ "3,3'" ] = g.add_vertex( label = "3,3'" ) # 5
    n[ "4,4'" ] = g.add_vertex( label = "4,4'" ) # 6
    n[ "5,1'" ] = g.add_vertex( label = "5,1'" ) # 7
    n[ "5,5'" ] = g.add_vertex( label = "5,5'" ) # 8

    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "3,3'" ] )
    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "1,1'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "3,2'" ] )
    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "1,5'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "3,3'" ] )
    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "2,2'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "2,3'" ], vertex2 = n[ "3,2'" ] )
    g.add_edge( vertex1 = n[ "2,3'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "3,2'" ], vertex2 = n[ "5,1'" ] )

    g.add_edge( vertex1 = n[ "3,3'" ], vertex2 = n[ "4,4'" ] )
    g.add_edge( vertex1 = n[ "3,3'" ], vertex2 = n[ "5,5'" ] )

    g.add_edge( vertex1 = n[ "4,4'" ], vertex2 = n[ "5,1'" ] )
    g.add_edge( vertex1 = n[ "4,4'" ], vertex2 = n[ "5,5'" ] )

    subgraph = maximum_clique.selected_subgraph(
      graph = g,
      vertices = g.adjacent_vertices( vertex = n[ "2,2'"] )
      )
    vertices = list( subgraph.vertices() )
    self.assertEqual( len( vertices ), 3 )
    self.assertEqual(
      set( subgraph.vertex_label( vertex = v ) for v in vertices ),
      set( [ "3,3'", "4,4'", "5,5'" ] )
      )

    edges = list( subgraph.edges() )
    self.assertEqual( len( edges ), 3 )
    self.assertEqual(
      set(
        frozenset(
          [
            subgraph.vertex_label( vertex = subgraph.source( edge = e ) ),
            subgraph.vertex_label( vertex = subgraph.target( edge = e ) ),
            ]
          )
        for e in edges
        ),
      set(
        [
          frozenset( [ "3,3'", "4,4'" ] ),
          frozenset( [ "3,3'", "5,5'" ] ),
          frozenset( [ "4,4'", "5,5'" ] ),
          ]
        )
      )


  def test_adjacency_list_undirected_vector_set(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_list_set(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "set",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_vector_vector(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "vector",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


  def test_adjacency_list_undirected_list_vector(self):

    try:
      g = graph.adjacency_list(
        graph_type = "undirected",
        vertex_type = "list",
        edge_type = "vector",
        )

    except NotImplementedError:
      pass

    else:
      self.manipulation( g )


suite_rascal = unittest.TestLoader().loadTestsFromTestCase(
  TestRascal
  )
suite_greedy = unittest.TestLoader().loadTestsFromTestCase(
  TestGreedy
  )
suite_compatibility_graph = unittest.TestLoader().loadTestsFromTestCase(
  TestCompatibilityGraph
  )
suite_selected_subgraph = unittest.TestLoader().loadTestsFromTestCase(
  TestSelectedSubgraph
  )


alltests = unittest.TestSuite(
  [
    suite_rascal,
    suite_greedy,
    suite_compatibility_graph,
    suite_selected_subgraph,
    ]
  )


def load_tests(loader, tests, pattern):

  return alltests


if __name__ == "__main__":
  unittest.TextTestRunner( verbosity = 2 ).run( alltests )