/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkSQLDatabaseGraphSource.cxx

  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
/*----------------------------------------------------------------------------
 Copyright (c) Sandia Corporation
 See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
----------------------------------------------------------------------------*/

#include "vtkSQLDatabaseGraphSource.h"

#include "vtkDataSetAttributes.h"
#include "vtkDirectedGraph.h"
#include "vtkUndirectedGraph.h"
#include "vtkEventForwarderCommand.h"
#include "vtkExecutive.h"
#include "vtkIdTypeArray.h"
#include "vtkInformation.h"
#include "vtkInformationVector.h"
#include "vtkObjectFactory.h"
#include "vtkRowQueryToTable.h"
#include "vtkSQLDatabase.h"
#include "vtkSQLQuery.h"
#include "vtkSmartPointer.h"
#include "vtkTableToGraph.h"
#include "vtkUndirectedGraph.h"

//---------------------------------------------------------------------------
class vtkSQLDatabaseGraphSource::implementation
{
public:
  implementation() :
    Database(0),
    EdgeQuery(0),
    EdgeTable(0),
    VertexQuery(0),
    VertexTable(0),
    TableToGraph(vtkTableToGraph::New())
  {
  }

  ~implementation()
  {
    if(this->TableToGraph)
      this->TableToGraph->Delete();
    if(this->VertexTable)
      this->VertexTable->Delete();
    if(this->VertexQuery)
      this->VertexQuery->Delete();
    if(this->EdgeTable)
      this->EdgeTable->Delete();
    if(this->EdgeQuery)
      this->EdgeQuery->Delete();
    if(this->Database)
      this->Database->Delete();
  }

  vtkStdString URL;
  vtkStdString Password;
  vtkStdString EdgeQueryString;
  vtkStdString VertexQueryString;

  vtkSQLDatabase* Database;
  vtkSQLQuery* EdgeQuery;
  vtkRowQueryToTable* EdgeTable;
  vtkSQLQuery* VertexQuery;
  vtkRowQueryToTable* VertexTable;
  vtkTableToGraph* TableToGraph;
};

vtkCxxRevisionMacro(vtkSQLDatabaseGraphSource, "1.2");
vtkStandardNewMacro(vtkSQLDatabaseGraphSource);

//---------------------------------------------------------------------------
vtkSQLDatabaseGraphSource::vtkSQLDatabaseGraphSource() :
  Implementation(new implementation()),
  Directed(true)
{
  this->SetNumberOfInputPorts(0);
  this->SetNumberOfOutputPorts(1);
  this->GenerateEdgePedigreeIds = true;
  this->EdgePedigreeIdArrayName = 0;
  this->SetEdgePedigreeIdArrayName("id");
  
  // Set up eventforwarder
  this->EventForwarder = vtkEventForwarderCommand::New();
  this->EventForwarder->SetTarget(this);
  
  // Now forward progress events from the graph layout
  this->Implementation->TableToGraph->AddObserver(vtkCommand::ProgressEvent, 
                                 this->EventForwarder);
}

//---------------------------------------------------------------------------
vtkSQLDatabaseGraphSource::~vtkSQLDatabaseGraphSource()
{
  delete this->Implementation;
  this->SetEdgePedigreeIdArrayName(0);
  this->EventForwarder->Delete();
}

//---------------------------------------------------------------------------
void vtkSQLDatabaseGraphSource::PrintSelf(ostream& os, vtkIndent indent)
{
  this->Superclass::PrintSelf(os, indent);
  os << indent << "URL: " << this->Implementation->URL << endl;
  os << indent << "EdgeQuery: " << this->Implementation->EdgeQueryString << endl;
  os << indent << "VertexQuery: " << this->Implementation->VertexQueryString << endl;
  os << indent << "Directed: " << this->Directed << endl;
  os << indent << "GenerateEdgePedigreeIds: " << this->GenerateEdgePedigreeIds << endl;
  os << indent << "EdgePedigreeIdArrayName: " << (this->EdgePedigreeIdArrayName ? this->EdgePedigreeIdArrayName : "(null)" ) << endl;
}

vtkStdString vtkSQLDatabaseGraphSource::GetURL()
{
  return this->Implementation->URL;
}

void vtkSQLDatabaseGraphSource::SetURL(const vtkStdString& url)
{
  if(url == this->Implementation->URL)
    return;

  if(this->Implementation->EdgeQuery)
    {
    this->Implementation->EdgeQuery->Delete();
    this->Implementation->EdgeQuery = 0;
    }
  
  if(this->Implementation->VertexQuery)
    {
    this->Implementation->VertexQuery->Delete();
    this->Implementation->VertexQuery = 0;
    }
  
  if(this->Implementation->Database)
    {
    this->Implementation->Database->Delete();
    this->Implementation->Database = 0;
    }
  
  this->Implementation->URL = url;
  
  this->Modified();
}

void vtkSQLDatabaseGraphSource::SetPassword(const vtkStdString& password)
{
  if(password == this->Implementation->Password)
    return;

  if(this->Implementation->EdgeQuery)
    {
    this->Implementation->EdgeQuery->Delete();
    this->Implementation->EdgeQuery = 0;
    }
  
  if(this->Implementation->VertexQuery)
    {
    this->Implementation->VertexQuery->Delete();
    this->Implementation->VertexQuery = 0;
    }
  
  if(this->Implementation->Database)
    {
    this->Implementation->Database->Delete();
    this->Implementation->Database = 0;
    }
  
  this->Implementation->Password = password;
  
  this->Modified();
}

vtkStdString vtkSQLDatabaseGraphSource::GetEdgeQuery()
{
  return this->Implementation->EdgeQueryString;
}

void vtkSQLDatabaseGraphSource::SetEdgeQuery(const vtkStdString& query)
{
  if(query == this->Implementation->EdgeQueryString)
    return;

  this->Implementation->EdgeQueryString = query;
  this->Modified();
}

vtkStdString vtkSQLDatabaseGraphSource::GetVertexQuery()
{
  return this->Implementation->VertexQueryString;
}

void vtkSQLDatabaseGraphSource::SetVertexQuery(const vtkStdString& query)
{
  if(query == this->Implementation->VertexQueryString)
    return;

  this->Implementation->VertexQueryString = query;
  this->Modified();
}

void vtkSQLDatabaseGraphSource::AddLinkVertex(const char* column, const char* domain, int hidden)
{
  this->Implementation->TableToGraph->AddLinkVertex(column, domain, hidden);
  this->Modified();
}

void vtkSQLDatabaseGraphSource::ClearLinkVertices()
{
  this->Implementation->TableToGraph->ClearLinkVertices();
  this->Modified();
}

void vtkSQLDatabaseGraphSource::AddLinkEdge(const char* column1, const char* column2)
{
  this->Implementation->TableToGraph->AddLinkEdge(column1, column2);
  this->Modified();
}

void vtkSQLDatabaseGraphSource::ClearLinkEdges()
{
  this->Implementation->TableToGraph->ClearLinkEdges();
  this->Modified();
}


//---------------------------------------------------------------------------
int vtkSQLDatabaseGraphSource::RequestDataObject(
  vtkInformation*, 
  vtkInformationVector**, 
  vtkInformationVector*)
{
  vtkGraph* output = 0;
  if(this->Directed)
    {
    output = vtkDirectedGraph::New();
    }
  else
    {
    output = vtkUndirectedGraph::New();
    }
  this->GetExecutive()->SetOutputData(0, output);
  output->Delete();

  return 1;
}

//---------------------------------------------------------------------------
int vtkSQLDatabaseGraphSource::RequestData(
  vtkInformation*, 
  vtkInformationVector**, 
  vtkInformationVector* outputVector)
{
  if(this->Implementation->URL.empty())
    return 1;

  if(this->Implementation->EdgeQueryString.empty())
    return 1;
    
  // Set Progress Text
  this->SetProgressText("DatabaseGraphSource");  
    
  // I've started so 1% progress :) 
  this->UpdateProgress(.01);
  
  // Setup the database if it doesn't already exist ...
  if(!this->Implementation->Database)
    {
    this->Implementation->Database = vtkSQLDatabase::CreateFromURL(this->Implementation->URL);
    if(!this->Implementation->Database)
      {
      vtkErrorMacro(<< "Error creating database using URL: " << this->Implementation->URL.c_str());
      return 0;
      }

    if(!this->Implementation->Database->Open(this->Implementation->Password))
      {
      this->Implementation->Database->Delete();
      this->Implementation->Database = 0;
      
      vtkErrorMacro(<< "Error opening database: " << this->Implementation->URL.c_str());
      return 0;
      }
    }
    
  // I have a database: 5% progress 
  this->UpdateProgress(.05);

  // Setup the edge query if it doesn't already exist ...
  if(!this->Implementation->EdgeQuery)
    {
    this->Implementation->EdgeQuery = this->Implementation->Database->GetQueryInstance();
    if(!this->Implementation->EdgeQuery)
      {
      vtkErrorMacro(<< "Internal error creating edge query instance.");
      return 0;
      }
    }

  this->Implementation->EdgeQuery->SetQuery(this->Implementation->EdgeQueryString.c_str());
  if(!this->Implementation->EdgeQuery->Execute())
    {
    vtkErrorMacro(<< "Error executing edge query: " << this->Implementation->EdgeQueryString.c_str());
    return 0;
    }
    
  // Executed edge query: 30% progress
  this->UpdateProgress(.3);   

  if(!this->Implementation->EdgeTable)
    {
    this->Implementation->EdgeTable = vtkRowQueryToTable::New();
    }
  this->Implementation->EdgeTable->SetQuery(this->Implementation->EdgeQuery);

  this->Implementation->TableToGraph->SetInputConnection(0, this->Implementation->EdgeTable->GetOutputPort());

  // Setup the (optional) vertex query if it doesn't already exist ...
  if(this->Implementation->VertexQueryString.size())
    {
    if(!this->Implementation->VertexQuery)
      {
      this->Implementation->VertexQuery = this->Implementation->Database->GetQueryInstance();
      if(!this->Implementation->VertexQuery)
        {
        vtkErrorMacro(<< "Internal error creating vertex query instance.");
        return 0;
        }
      }

    this->Implementation->VertexQuery->SetQuery(this->Implementation->VertexQueryString.c_str());
    if(!this->Implementation->VertexQuery->Execute())
      {
      vtkErrorMacro(<< "Error executing vertex query: " << this->Implementation->VertexQueryString.c_str());
      return 0;
      }
      
    // Executed vertex query: 50% progress 
    this->UpdateProgress(.5); 

    if(!this->Implementation->VertexTable)
      {
      this->Implementation->VertexTable = vtkRowQueryToTable::New();
      
      }
    this->Implementation->VertexTable->SetQuery(this->Implementation->VertexQuery);

    this->Implementation->TableToGraph->SetInputConnection(1, this->Implementation->VertexTable->GetOutputPort());
    }
    
  // Set Progress Text
  this->SetProgressText("DatabaseGraphSource:TableToGraph");

  // Get the graph output ...
  this->Implementation->TableToGraph->SetDirected(this->Directed);
  this->Implementation->TableToGraph->Update();
  
  // Set Progress Text
  this->SetProgressText("DatabaseGraphSource");
  
  // Finished table to graph: 90% progress 
  this->UpdateProgress(.9); 

  vtkGraph* const output = vtkGraph::SafeDownCast(
    outputVector->GetInformationObject(0)->Get(vtkDataObject::DATA_OBJECT()));

  output->ShallowCopy(this->Implementation->TableToGraph->GetOutput());

  if (this->GenerateEdgePedigreeIds)
    {
    vtkIdType numEdges = output->GetNumberOfEdges();
    vtkSmartPointer<vtkIdTypeArray> arr =
      vtkSmartPointer<vtkIdTypeArray>::New();
    arr->SetName(this->EdgePedigreeIdArrayName);
    arr->SetNumberOfTuples(numEdges);
    for (vtkIdType i = 0; i < numEdges; ++i)
      {
      arr->InsertValue(i, i);
      }
    output->GetEdgeData()->SetPedigreeIds(arr);
    }
  else
    {
    vtkAbstractArray* arr = output->GetEdgeData()->GetAbstractArray(this->EdgePedigreeIdArrayName);
    if (!arr)
      {
      vtkErrorMacro(<< "Could not find edge pedigree id array: " << this->EdgePedigreeIdArrayName);
      return 0;
      }
    output->GetEdgeData()->SetPedigreeIds(arr);
    }
    
  // Done: 100% progress 
  this->UpdateProgress(1);

  return 1;
}

