#include <cpPlugins/Interface/Workspace.h>
#include <third_party/tinyxml/tinyxml.h>

// -------------------------------------------------------------------------
std::string cpPlugins::Interface::Workspace::
LoadWorkspace( const std::string& fname )
{
  TiXmlDocument* doc = new TiXmlDocument( fname.c_str( ) );
  doc->LoadFile( );
  TiXmlElement* root = doc->RootElement( );
  if( std::string( root->Value( ) ) != "cpPlugins_Workspace" )
    return( "cpPlugins::Interface::Workspace: No valid workspace" );
  std::stringstream err;

  // Read plugins files
  TiXmlElement* plugins = root->FirstChildElement( "plugins" );
  while( plugins != NULL )
  {
    const char* value = plugins->Attribute( "filename" );
    if( value != NULL )
    {
      if( !( this->LoadPlugins( value ) ) )
        err << "no valid plugins file \"" << value << "\"" << std::endl;

    } // fi
    plugins = plugins->NextSiblingElement( "plugins" );

  } // elihw

  // Read plugins paths
  plugins = root->FirstChildElement( "plugins_dir" );
  while( plugins != NULL )
  {
    const char* value = plugins->Attribute( "path" );
    if( value != NULL )
    {
      int recursive;
      if( plugins->QueryIntAttribute( "recursive", &recursive ) != TIXML_SUCCESS )
        recursive = 0;
      if( !( this->LoadPluginsPath( value, recursive == 1 ) ) )
        err << "No valid plugins path \"" << value << "\"" << std::endl;

    } // fi
    plugins = plugins->NextSiblingElement( "plugins_dir" );

  } // elihw

  // Read filters
  TiXmlElement* filter = root->FirstChildElement( "filter" );
  while( filter != NULL )
  {
    const char* class_value = filter->Attribute( "class" );
    const char* name_value = filter->Attribute( "name" );
    if( class_value != NULL && name_value != NULL )
    {
      if( this->CreateFilter( class_value, name_value ) )
      {
        // Read parameters
        TParameters* parameters = this->GetParameters( name_value );
        TiXmlElement* param = filter->FirstChildElement( "parameter" );
        while( param != NULL )
        {
          const char* param_name = param->Attribute( "name" );
          const char* param_type = param->Attribute( "type" );
          if( param_name != NULL && param_type != NULL )
          {
            std::string param_type_str( param_type );
            const char* value = param->Attribute( "value" );
            if( value != NULL )
            {
              std::istringstream value_str( value );
              if( param_type_str == "String" )
                parameters->SetString( param_name, value );
              else if( param_type_str == "Bool" )
                parameters->SetBool( param_name, value[ 0 ] != '0' );
              else if( param_type_str == "Int" )
              {
                TParameters::TInt v;
                value_str >> v;
                parameters->SetInt( param_name, v );
              }
              else if( param_type_str == "Uint" )
              {
                TParameters::TUint v;
                value_str >> v;
                parameters->SetUint( param_name, v );
              }
              else if( param_type_str == "Real" )
              {
                TParameters::TReal v;
                value_str >> v;
                parameters->SetReal( param_name, v );
              }
              /* TODO
                 else if( param_type_str == "Index" )
                 else if( param_type_str == "Point" )
                 else if( param_type_str == "Vector" )
              */
            }
            else
            {
              if( param_type_str == "StringList" )
              {
                TiXmlElement* item = param->FirstChildElement( "item" );
                while( item != NULL )
                {
                  value = item->Attribute( "value" );
                  if( value != NULL )
                    parameters->AddToStringList( param_name, value );
                  item = item->NextSiblingElement( "item" );

                } // elihw
              }
              else if( param_type_str == "BoolList" )
              {
                TiXmlElement* item = param->FirstChildElement( "item" );
                while( item != NULL )
                {
                  value = item->Attribute( "value" );
                  if( value != NULL )
                    parameters->AddToBoolList( param_name, value[ 0 ] != '0' );
                  item = item->NextSiblingElement( "item" );

                } // elihw
              }
              else if( param_type_str == "IntList" )
              {
                TiXmlElement* item = param->FirstChildElement( "item" );
                while( item != NULL )
                {
                  value = item->Attribute( "value" );
                  if( value != NULL )
                  {
                    std::istringstream value_str( value );
                    TParameters::TInt v;
                    value_str >> v;
                    parameters->AddToIntList( param_name, v );

                  } // fi
                  item = item->NextSiblingElement( "item" );

                } // elihw
              }
              else if( param_type_str == "UintList" )
              {
                TiXmlElement* item = param->FirstChildElement( "item" );
                while( item != NULL )
                {
                  value = item->Attribute( "value" );
                  if( value != NULL )
                  {
                    std::istringstream value_str( value );
                    TParameters::TUint v;
                    value_str >> v;
                    parameters->AddToUintList( param_name, v );

                  } // fi
                  item = item->NextSiblingElement( "item" );

                } // elihw
              }
              else if( param_type_str == "RealList" )
              {
                TiXmlElement* item = param->FirstChildElement( "item" );
                while( item != NULL )
                {
                  value = item->Attribute( "value" );
                  if( value != NULL )
                  {
                    std::istringstream value_str( value );
                    TParameters::TReal v;
                    value_str >> v;
                    parameters->AddToRealList( param_name, v );

                  } // fi
                  item = item->NextSiblingElement( "item" );

                } // elihw
              }
              /* TODO
                 else if( param_type_str == "IndexList" )
                 else if( param_type_str == "PointList" )
                 else if( param_type_str == "VectorList" )
                 else if( param_type_str == "Choices" );
              */
            } // fi

          } // fi
          param = param->NextSiblingElement( "parameter" );

        } // elihw
      }
      else
        err
          << "No valid class \"" << class_value << "\" with name \""
          << name_value << "\"" << std::endl;
    }
    else
      err << "Incomplete data." << std::endl;
    filter = filter->NextSiblingElement( "filter" );

  } // elihw

  // Read filters
  TiXmlElement* connection = root->FirstChildElement( "connection" );
  while( connection != NULL )
  {
    TiXmlElement* orig = connection->FirstChildElement( "origin" );
    TiXmlElement* dest = connection->FirstChildElement( "destination" );
    if( orig != NULL && dest != NULL )
    {
      const char* orig_filter = orig->Attribute( "filter" );
      const char* dest_filter = dest->Attribute( "filter" );
      const char* orig_name = orig->Attribute( "name" );
      const char* dest_name = dest->Attribute( "name" );
      if(
        orig_filter != NULL && dest_filter != NULL &&
        orig_name != NULL && dest_name != NULL
        )
        this->Connect( orig_filter, dest_filter, orig_name, dest_name );

    } // fi
    connection = connection->NextSiblingElement( "connection" );

  } // elihw

  // Finish and return
  delete doc;
  return( err.str( ) );
}

// -------------------------------------------------------------------------
std::string cpPlugins::Interface::Workspace::
SaveWorkspace( const std::string& fname ) const
{
  return( "" );
}

// eof - $RCSfile$