package require nx

namespace eval ::Base {

  nx::Class create Node {}


  nx::Class create Edge {
    :property n1:object,type=Node
    :property n2:object,type=Node

    :public method equals {e:object,type=Edge, required} {
      # Check if the nodes are equal
      if {[$e cget -n1] == ${:n1} && [$e cget -n2] == ${:n2}} {
        return true
      } elseif {[$e cget -n2] == ${:n1} && [$e cget -n1] == ${:n2}} {
        return true
      } else {
        return false
      }
    }
  }

  nx::Class create Graph {
    :property edges {}
    :property nodes {}

    :private add_edge {n1,type=Node,required,n2,type=Node,required} {
      Edge create e -n1 $n1 -n2 $n2
      set checker 0
      foreach {key value} [array get edges] {
        if {e equals $value} {
          set checker 1
        }
      }
      if {checker == 1}{
        puts "The edge is in the list already"
      } else {
        lappend :edges $e
      }
    }

    :private add_node {n,type=Node,required} {
      set checker 0
      foreach {key value} [array get nodes] {
        if {$n == $value} {
          set checker 1
        }
      }
      if {checker == 0} {
        lappend :nodes $n
      }
    }

    :public method add {-n1:object,type=Node, required,-n2:object,type=Node, required} {
      : -add_node $n1
      : -add_node $n2
      : -add_edge $n1 $n2
    }
  }

}


::Base::Node create n1
::Base::Node create n2
::Base::Node create n3

::Base::Edge create e1 -n1 n1 -n2 n2
::Base::Edge create e2 -n1 n2 -n2 n1
::Base::Edge create e3 -n1 n2 -n2 n3

puts [e1 cget -n1]
puts [e1 equals e2]
puts [e1 equals e3]
puts [e1 info class]

set G [::Base::Graph new]
    set n1 [::Base::Node new]
    set n2 [::Base::Node new]
    set n3 [::Base::Node new]
    set n4 [::Base::Node new]
    set n5 [::Base::Node new]
    set n6 [::Base::Node new]
    set n7 [::Base::Node new]
  set n8 [::Base::Node new]
    $G add $n1 $n2
    $G add $n1 $n3
    $G add $n1 $n4
    $G add $n1 $n5
    $G add $n5 $n6
    $G add $n5 $n7
  $G add $n5 $n8

;# e1 equals e2