// -*- c++ -*-

#ifndef HUGO_FULL_GRAPH_H
#define HUGO_FULL_GRAPH_H

///\ingroup graphs
///\file
///\brief FullGraph and SymFullGraph classes.

#include <vector>
#include <climits>

#include <hugo/invalid.h>

#include <hugo/map_registry.h>
#include <hugo/default_map.h>

#include <hugo/map_defines.h>

namespace hugo {

/// \addtogroup graphs
/// @{

  ///A full graph class.

  ///This is a simple and fast directed full graph implementation.
  ///It is completely static, so you can neither add nor delete either
  ///edges or nodes.
  ///Otherwise it conforms to the graph interface documented under
  ///the description of \ref GraphSkeleton.
  ///\sa \ref GraphSkeleton.
  ///\todo What about loops?
  ///\todo Don't we need SymEdgeMap?
  ///
  ///\author Alpar Juttner
  class FullGraph {
    int NodeNum;
    int EdgeNum;
  public:

    typedef FullGraph Graph;

    class Node;
    class Edge;

    class NodeIt;
    class EdgeIt;
    class OutEdgeIt;
    class InEdgeIt;
    

    /// Creating map registries.
    CREATE_MAP_REGISTRIES;
    /// Creating node and edge maps.
    CREATE_MAPS(DefaultMap);
    
  public:

    ///Creates a full graph with \c n nodes.
    FullGraph(int n) : NodeNum(n), EdgeNum(NodeNum*NodeNum) { }
    ///
    FullGraph(const FullGraph &_g)
      : NodeNum(_g.nodeNum()), EdgeNum(NodeNum*NodeNum) { }
    
    ///Number of nodes.
    int nodeNum() const { return NodeNum; }
    ///Number of edges.
    int edgeNum() const { return EdgeNum; }

    /// Maximum node ID.
    
    /// Maximum node ID.
    ///\sa id(Node)
    int maxNodeId() const { return NodeNum-1; }
    /// Maximum edge ID.
    
    /// Maximum edge ID.
    ///\sa id(Edge)
    int maxEdgeId() const { return EdgeNum-1; }

    Node tail(Edge e) const { return e.n%NodeNum; }
    Node head(Edge e) const { return e.n/NodeNum; }

    NodeIt& first(NodeIt& v) const {
      v=NodeIt(*this); return v; }
    EdgeIt& first(EdgeIt& e) const { 
      e=EdgeIt(*this); return e; }
    OutEdgeIt& first(OutEdgeIt& e, const Node v) const { 
      e=OutEdgeIt(*this,v); return e; }
    InEdgeIt& first(InEdgeIt& e, const Node v) const { 
      e=InEdgeIt(*this,v); return e; }

    /// Node ID.
    
    /// The ID of a valid Node is a nonnegative integer not greater than
    /// \ref maxNodeId(). The range of the ID's is not surely continuous
    /// and the greatest node ID can be actually less then \ref maxNodeId().
    ///
    /// The ID of the \ref INVALID node is -1.
    ///\return The ID of the node \c v. 
    static int id(Node v) { return v.n; }
    /// Edge ID.
    
    /// The ID of a valid Edge is a nonnegative integer not greater than
    /// \ref maxEdgeId(). The range of the ID's is not surely continuous
    /// and the greatest edge ID can be actually less then \ref maxEdgeId().
    ///
    /// The ID of the \ref INVALID edge is -1.
    ///\return The ID of the edge \c e. 
    static int id(Edge e) { return e.n; }

    /// Finds an edge between two nodes.
    
    /// Finds an edge from node \c u to node \c v.
    ///
    /// If \c prev is \ref INVALID (this is the default value), then
    /// It finds the first edge from \c u to \c v. Otherwise it looks for
    /// the next edge from \c u to \c v after \c prev.
    /// \return The found edge or INVALID if there is no such an edge.
    Edge findEdge(Node u,Node v, Edge prev = INVALID) 
    {
      return prev.n == -1 ? Edge(*this, u.n, v.n) : INVALID;
    }
    
      
    class Node {
      friend class FullGraph;
      template <typename T> friend class NodeMap;

      friend class Edge;
      friend class OutEdgeIt;
      friend class InEdgeIt;
      friend class SymEdge;

    protected:
      int n;
      friend int FullGraph::id(Node v); 
      Node(int nn) {n=nn;}
    public:
      Node() {}
      Node (Invalid) { n=-1; }
      bool operator==(const Node i) const {return n==i.n;}
      bool operator!=(const Node i) const {return n!=i.n;}
      bool operator<(const Node i) const {return n<i.n;}
    };
    
    class NodeIt : public Node {
      const FullGraph *G;
      friend class FullGraph;
    public:
      NodeIt() : Node() { }
      NodeIt(const FullGraph& _G,Node n) : Node(n), G(&_G) { }
      NodeIt(Invalid i) : Node(i) { }
      NodeIt(const FullGraph& _G) : Node(_G.NodeNum?0:-1), G(&_G) { }
      ///\todo Undocumented conversion Node -\> NodeIt.
      NodeIt& operator++() { n=(n+2)%(G->NodeNum+1)-1;return *this; }
    };

    class Edge {
      friend class FullGraph;
      template <typename T> friend class EdgeMap;
      
      friend class Node;
      friend class NodeIt;
    protected:
      int n; //NodeNum*head+tail;
      friend int FullGraph::id(Edge e);

      Edge(int nn) : n(nn) {}
      Edge(const FullGraph &G, int tail, int head) : n(G.NodeNum*head+tail) {}
    public:
      Edge() { }
      Edge (Invalid) { n=-1; }
      bool operator==(const Edge i) const {return n==i.n;}
      bool operator!=(const Edge i) const {return n!=i.n;}
      bool operator<(const Edge i) const {return n<i.n;}
      ///\bug This is a workaround until somebody tells me how to
      ///make class \c SymFullGraph::SymEdgeMap friend of Edge
      int &idref() {return n;}
      const int &idref() const {return n;}
    };
    
    class EdgeIt : public Edge {
      friend class FullGraph;
    public:
      EdgeIt(const FullGraph& _G) : Edge(_G.EdgeNum-1) { }
      EdgeIt(const FullGraph&, Edge e) : Edge(e) { }
      EdgeIt (Invalid i) : Edge(i) { }
      EdgeIt() : Edge() { }
      EdgeIt& operator++() { --n; return *this; }

      ///\bug This is a workaround until somebody tells me how to
      ///make class \c SymFullGraph::SymEdgeMap friend of Edge
      int &idref() {return n;}
    };
    
    class OutEdgeIt : public Edge {
      const FullGraph *G;
      friend class FullGraph;
    public: 
      OutEdgeIt() : Edge() { }
      OutEdgeIt(const FullGraph& _G, Edge e) : Edge(e), G(&_G) { }
      OutEdgeIt (Invalid i) : Edge(i) { }

      OutEdgeIt(const FullGraph& _G,const Node v) : Edge(v.n), G(&_G) {}
      
      OutEdgeIt& operator++()
      { n+=G->NodeNum; if(n>=G->EdgeNum) n=-1; return *this; }

    };
    
    class InEdgeIt : public Edge {
      const FullGraph *G;
      friend class FullGraph;
    public: 
      InEdgeIt() : Edge() { }
      InEdgeIt(const FullGraph& _G, Edge e) : Edge(e), G(&_G) { }
      InEdgeIt (Invalid i) : Edge(i) { }
      InEdgeIt(const FullGraph& _G,Node v) : Edge(v.n*_G.NodeNum), G(&_G) {}
      InEdgeIt& operator++()
      { if(!((++n)%G->NodeNum)) n=-1; return *this; }
    };

  };

  /// @}  

} //namespace hugo




#endif //HUGO_FULL_GRAPH_H