#include <fstream>
#include <iostream>

#include <algorithm>
#include <cstring>
#include <map>
#include <vector>
#include <sstream>

#if defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
#  define cpPlugins_STRTOK( A, B, N ) strtok_s( A, B, N )
#else // defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )
#  define cpPlugins_STRTOK( A, B, N ) std::strtok( A, B )
#endif // defined( WIN32 ) || defined( _WIN32 ) || defined( __WIN32__ )

// -------------------------------------------------------------------------
typedef std::vector< std::string >      TLines;
typedef std::map< char, TLines >        TParsedLines;
typedef std::map< std::string, TLines > TVariables;

// -------------------------------------------------------------------------
bool cpPlugins_ISBLANK( const char& value );
TLines Tokenize( const std::string& str, const std::string& delims );
std::string Replace(
  const std::string& str, const std::string& sub, const std::string& nsub
  );
bool ReadFile( TParsedLines& lines, const std::string& fname );
void ExpandGroups( TLines& res, const TLines& lines, const TVariables& vars );
void ExpandVariables( TLines& res, const TLines& lines, const TVariables& vars );
void ParseIncludes( TLines& res, const TLines& lines, const std::string& ext = "" );
void PrintLines(
  const std::string& prefix, const std::string& suffix,
  const TLines& lines, std::ostream& out
  );

// -------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
  if( argc < 5 )
  {
    std::cerr
      << "Usage: " << argv[ 0 ]
      << " input_definitions library_name header_file source_file"
      << std::endl;
    return( 1 );

  } // fi
  std::string input_definitions_fname = argv[ 1 ];
  std::string library_name = argv[ 2 ];
  std::string header_file_fname = argv[ 3 ];
  std::string source_file_fname = argv[ 4 ];

  // Read file and simple parse it
  TParsedLines lines;
  if( !ReadFile( lines, input_definitions_fname ) )
  {
    std::cerr
      << "Error opening file: \""
      << input_definitions_fname << "\""
      << std::endl;
    return( 1 );

  } // fi

  // Expand variable definitions
  TVariables vars;
  for( auto dIt = lines[ 'd' ].begin( ); dIt != lines[ 'd' ].end( ); ++dIt )
  {
    auto tokens = Tokenize( *dIt, "=;" );
    auto tIt = tokens.begin( );
    auto vName = *tIt;
    tIt++;
    for( ; tIt != tokens.end( ); ++tIt )
      vars[ vName ].push_back( *tIt );

    TLines res;
    ExpandVariables( res, vars[ vName ], vars );
    vars[ vName ] = res;

  } // rof

  // First include section
  TLines first_includes, normal_includes, template_includes, template_sources;
  ParseIncludes( first_includes, lines[ 'f' ] );
  ParseIncludes( normal_includes, lines[ 'i' ] );
  ParseIncludes( template_includes, lines[ 't' ] );
  ParseIncludes( template_sources, lines[ 't' ], "xx" );

  // Expand groups
  TLines pre_classes;
  ExpandGroups( pre_classes, lines[ 'c' ], vars );

  // Expand variables
  TLines real_classes;
  ExpandVariables( real_classes, pre_classes, vars );

  // Prepare header file
  std::ofstream header_file( header_file_fname.c_str( ) );
  if( !header_file )
  {
    std::cerr
      << "Error opening \"" << header_file_fname
      << "\" for writing." << std::endl;
    return( 1 );

  } // fi

  // Print header
  header_file
    << "#ifndef __" << library_name << "__H__" << std::endl
    << "#define __" << library_name << "__H__" << std::endl<< std::endl
    << "#include <cpPlugins_Config.h>" << std::endl
    << "#include <" << library_name << "_Export.h>" << std::endl << std::endl;
  PrintLines( "", "", lines[ 'b' ], header_file );
  header_file << std::endl;
  PrintLines( "", "", first_includes, header_file );
  header_file
    << "#ifdef " << library_name << "_EXPORTS" << std::endl
    << "#  define " << library_name << "_PREFIX template class "
    << library_name << "_EXPORT" << std::endl
    << "#else // " << library_name << "_EXPORTS" << std::endl
    << "#  define " << library_name
    << "_PREFIX extern template class" << std::endl
    << "#endif // "
    << library_name << "_EXPORTS" << std::endl;
  PrintLines( "", "", normal_includes, header_file );
  PrintLines( "", "", template_includes, header_file );
  header_file
    << std::endl << "#ifdef " << library_name << "_EXPORTS" << std::endl;
  PrintLines( "", "", template_sources, header_file );
  header_file << "#endif // " << library_name << "_EXPORTS" << std::endl;
  header_file << std::endl;
  PrintLines(
    library_name + std::string( "_PREFIX " ), ";", real_classes, header_file
    );
  header_file
    << std::endl << "#endif // __" << library_name << "__H__" << std::endl;
  header_file.close( );

  // Write source file
  std::ofstream source_file( source_file_fname );
  if( !source_file )
  {
    std::cerr
      << "Error opening \"" << header_file_fname << "\" for writing." << std::endl;
    return( 1 );

  } // fi
  source_file
    << "#include \"" << header_file_fname << "\"" << std::endl;
  source_file.close( );
  return( 0 );
}

// -------------------------------------------------------------------------
bool cpPlugins_ISBLANK( const char& value )
{
  return( value == ' ' || value == '\t' || value == '\n' || value == '\r' );
}

// -------------------------------------------------------------------------
TLines Tokenize( const std::string& str, const std::string& delims )
{
  TLines tokens;
  if( str.size( ) > 0 )
  {
    auto ssize = str.size( );
    char* buffer = new char[ ssize + 1 ];
    for( unsigned long i = 0; i < ssize; ++i )
      buffer[ i ] = str[ i ];
    buffer[ ssize ] = '\0';
    char* next;
    char* it = cpPlugins_STRTOK( buffer, delims.c_str( ), &next );
    while( it != NULL )
    {
      tokens.push_back( std::string( it ) );
      it = cpPlugins_STRTOK( NULL, delims.c_str( ), &next );

    } // elihw
    delete [] buffer;

  } // fi
  return( tokens );
}

// -------------------------------------------------------------------------
std::string Replace(
  const std::string& str, const std::string& sub, const std::string& nsub
  )
{
  std::string res = str;
  size_t index;
  while( ( index = res.find( sub ) ) != std::string::npos )
    res.replace( index, sub.size( ), nsub );
  return( res );
}

// -------------------------------------------------------------------------
bool ReadFile( TParsedLines& lines, const std::string& fname )
{
  // Load file into a string stream
  std::ifstream file_stream( fname.c_str( ) );
  if( !file_stream )
    return( false );
  std::string buffer;
  file_stream.seekg( 0, std::ios::end );
  buffer.reserve( ( unsigned int )( file_stream.tellg( ) ) );
  file_stream.seekg( 0, std::ios::beg );
  buffer.assign(
    ( std::istreambuf_iterator< char >( file_stream ) ),
    std::istreambuf_iterator< char >( )
    );
  file_stream.close( );
  std::istringstream input_stream( buffer );

  // Read line by line
  std::string line;
  while( std::getline( input_stream, line ) )
  {
    auto cmd_pos = line.end( );
    auto arg_pos = line.end( );
    auto lIt = line.begin( );
    while( lIt != line.end( ) )
    {
      if( !cpPlugins_ISBLANK( *lIt ) )
      {
        if( cmd_pos == line.end( ) )
        {
          cmd_pos = lIt;
          ++lIt;
        }
        else if( arg_pos == line.end( ) )
        {
          arg_pos = lIt;
          lIt = line.end( );

        } // fi
      }
      else
        ++lIt;
      
    } // elihw
    char cmd = *cmd_pos;
    std::string arg;
    arg.resize( line.end( ) - arg_pos );
    std::copy( arg_pos, line.end( ), arg.begin( ) );
    lines[ cmd ].push_back( arg );

  } // elihw
  return( true );
}

// -------------------------------------------------------------------------
void ExpandGroups( TLines& res, const TLines& lines, const TVariables& vars )
{
  for( auto lIt = lines.begin( ); lIt != lines.end( ); ++lIt )
  {
    auto b_pos = lIt->find( "@{" );
    if( b_pos != std::string::npos )
    {
      auto e_pos = lIt->find( "}" );
      auto expansion = lIt->substr( b_pos + 2, e_pos - b_pos - 2 );
      auto tokens = Tokenize( expansion, ";" );
      for( auto tIt = tokens.begin( ); tIt != tokens.end( ); ++tIt )
      {
        auto vIt = vars.find( *tIt );
        if( vIt != vars.end( ) )
        {
          auto wIt = vIt->second.begin( );
          std::string values = *wIt;
          for( wIt++; wIt != vIt->second.end( ); ++wIt )
            values += ";" + *wIt;
          *tIt = Replace( *lIt, vIt->first, values );
        }
        else
          *tIt = lIt->substr( 0, b_pos ) + *tIt + lIt->substr( e_pos + 1 );

      } // rof
      ExpandGroups( res, tokens, vars );
    }
    else
      res.push_back( *lIt );

  } // rof
}

// -------------------------------------------------------------------------
void ExpandVariables( TLines& res, const TLines& lines, const TVariables& vars )
{
  for( auto lIt = lines.begin( ); lIt != lines.end( ); ++lIt )
  {
    auto b_pos = lIt->find( "#" );
    if( b_pos != std::string::npos )
    {
      auto tokens = Tokenize( lIt->substr( b_pos ), " ,;:{}[]()\"$&<>*" );
      std::string cmd = tokens[ 0 ];
      auto vIt = vars.find( cmd );
      if( vIt != vars.end( ) )
      {
        if( vIt->second.size( ) > 0 )
        {
          TLines new_res;
          for( auto wIt = vIt->second.begin( ); wIt != vIt->second.end( ); ++wIt )
            new_res.push_back( Replace( *lIt, cmd, *wIt ) );
          ExpandVariables( res, new_res, vars );

        } // fi

      } // fi
    }
    else
      res.push_back( *lIt );

  } // rof
}

// -------------------------------------------------------------------------
void ParseIncludes( TLines& res, const TLines& lines, const std::string& ext )
{
  for( auto lIt = lines.begin( ); lIt != lines.end( ); ++lIt )
    res.push_back(
      std::string( "#include <" ) + *lIt + ext + std::string( ">" )
      );
}

// -------------------------------------------------------------------------
void PrintLines(
  const std::string& prefix, const std::string& suffix,
  const TLines& lines, std::ostream& out
  )
{
  for( auto i = lines.begin( ); i != lines.end( ); ++i )
    out << prefix << *i << suffix << std::endl;
}

// eof - $RCSfile$