//=========================================================================
// $Id$
//
//This is the main program for the algorithm presented in WirthlinDAC05
//
//TO-DO:
//    1. Should be able to parse a .dot file as the algorithm input instead
//       of creating one by the program
//    2. firGraph should not return a value
//=========================================================================


//---------------------------------------------------------------------
// Header files inclusion
//---------------------------------------------------------------------
#include <iostream>
#include <string>
using namespace std;

#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/graphviz.hpp>
using namespace boost;

#include "Operator.hpp"
#include "helper.hpp"

//---------------------------------------------------------------------
// Global data structures and variables
//---------------------------------------------------------------------
static OperatorType* portType     = new BasicOperatorType("Port");
static OperatorType* addType      = new BasicOperatorType("+");
static OperatorType* subType      = new BasicOperatorType("-");
static OperatorType* constantType = new BasicOperatorType("Const");
static OperatorType* constMultType= new BasicOperatorType("*c");
static OperatorType* multType     = new BasicOperatorType("X");
static OperatorType* delayType    = new BasicOperatorType("z^-1");

typedef adjacency_list<
  vecS,
  vecS,
  bidirectionalS,
  BasicOperator> Graph;

//Class template of a property_writer
template < typename Graph >
class schedule_vertex_writer {
public:
  schedule_vertex_writer(Graph _g) : g(_g) {}
                       
  template <typename Vertex>
  void operator()(std::ostream& out, const Vertex& v) const {
    out << "[label=\"" << v 
        << "(" << g[v].getOperatorType()->getMnemonic() << ")" 
        << "\"]";
  }
private:
  Graph g;
};

//Function template to return an object of the above class
template <typename Graph>
inline schedule_vertex_writer<Graph>
make_schedule_vertex_writer(Graph g){
  return schedule_vertex_writer<Graph>(g);
}


//---------------------------------------------------------------------
// Function declarations
//---------------------------------------------------------------------
Graph firGraph(int tapNumber);




//---------------------------------------------------------------------
//Function description:
//    This is the main driver for the algorithm
//Input:
//    None
//Output:
//    A graph showing the scheduling result
//---------------------------------------------------------------------
int main(void)
{
  cout << "Algorithm starts..." << endl;

  //Step 1. Create an 8-tap FIR filter
  Graph firg = firGraph(8);
  
  // Print out the graph
  ofstream out("fir.dot");
  write_graphviz(out, firg, make_schedule_vertex_writer(firg));

}


//---------------------------------------------------------------------
//Function description:
//    This is a function that creates a FIR filter graph and returns it
//Input:
//    int tap -> tap number
//Output:
//    Graph -> The FIR filter graph
//---------------------------------------------------------------------
Graph firGraph(int tapNumber)
{
  Graph fg;

  //Declare all the nodes
  graph_traits<Graph>::vertex_descriptor 
    dataInNode,
    dataOutNode,
    tapsInNodes[tapNumber], 
    multiplyNodes[tapNumber],
    addNodes[tapNumber - 1];
  
  //Add nodes one by one
  dataInNode = add_vertex(fg);
  fg[dataInNode] = BasicOperator(portType, "dataIn");
  
  for ( int i=0 ; i<tapNumber ; i++ ) {
    tapsInNodes[i] = add_vertex(fg);
    fg[tapsInNodes[i]] = BasicOperator(portType, "tapIn"+any2string(i));
    
    multiplyNodes[i] = add_vertex(fg);
    fg[multiplyNodes[i]] = BasicOperator(multType, "multiply"+any2string(i));
    
    if ( i != tapNumber-1 ){
      addNodes[i] = add_vertex(fg);  
      fg[addNodes[i]] = BasicOperator(addType, "add"+any2string(i));
    }
  }
  
  dataOutNode = add_vertex(fg);
  fg[dataOutNode] = BasicOperator(portType, "dataOut");
  
  //Add edges
  for ( int i=0 ; i<tapNumber ; i++ ) {
    add_edge(dataInNode, multiplyNodes[i], fg);
  }

  for ( int i=0 ; i<tapNumber ; i++ ) {
    add_edge(tapsInNodes[i], multiplyNodes[i], fg);
  }

  add_edge(multiplyNodes[0], addNodes[0], fg);

  for ( int i=1 ; i<tapNumber ; i++ ) {
    add_edge(multiplyNodes[i], addNodes[i-1], fg);
  }

  for ( int i=0 ; i<tapNumber-2 ; i++ ) {
    add_edge(addNodes[i], addNodes[i+1], fg);
  }

  add_edge(addNodes[tapNumber-2], dataOutNode, fg);

  return fg;
}