/**********************************************************************
  *                                                                    *
  * Copyright (c) 2003 INFN - Sezione di Napoli                        *
  *                                                                    *
  * For more information (including a list of authors) see             *
  * the README file                                                    *
  *                                                                    *
  * This library is free software; you can redistribute it and/or      *
  * modify it under the terms of the GNU General Public License        *
  * as published by the Free Software Foundation; either version 2     *
  * of the License, or (at your option) any later version.             *
  *                                                                    *
  * This library is distributed in the hope that it will be useful,    *
  * but WITHOUT ANY WARRANTY; without even the implied warranty of     *
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the       *
  * GNU General Public License for more details.                       *
  *                                                                    *
  * You should have received a copy of the GNU General Public License  *
  * along with this library (see file COPYING); if not, write to the   *
  * Free Software Foundation, Inc., 59 Temple Place, Suite 330,        *
  * Boston, MA 02111-1307 USA, or contact the authors.                 *
  *                                                                    *
  **********************************************************************/
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
using namespace std;
#include "makeHeader.h"
#include "combinations.h"

struct makeHeader_RandomGeneratorIndependent : makeHeader
{
  makeHeader_RandomGeneratorIndependent( ostream& out, int n ) : makeHeader ( out ) {
    copyrightNotice();
    head( "RANDOMGENERATORINDEPENDENT_H" );
    _out << "#include \"StatTools/Pdf/Independent.h\"\n"
	 << "#include \"StatTools/Pdf/RandomGenerator.h\"\n\n";
    ns( "Pdf" );

    _out << "template< typename F, typename Generator, int n = F::vars >\n"
	 << "struct RandomGeneratorIndependent1 { };\n\n";

    for ( int i = 1; i <= n; i++ )
    {
      _out << "template< typename F, typename Generator >\n"
	   << "struct RandomGeneratorIndependent1< F, Generator, " << i << " > : \n"
	   << "  public Arguments< ";
      list (  "typename F::arg", i );
      _out << " > {\n"
	   << "  typedef RandomGeneratorIndependent1< F, Generator, " << i << " > I;\n"
	   << "  typedef Independent1< F > Pdf;\n"
	   << "  RandomGeneratorIndependent1( const Independent1< F >& f ) :\n"
	   << "    _r( f.f() ) { }\n"
	   << "  void generate( ";
      list2 ( "typename I::arg", i, " & x" );
      _out << " ) const\n"
	   << "  { _r.generate( ";
      list  ( "x", i );
      _out << " ); }\n"
	   << "private:\n"
	   << "  RandomGenerator< F, Generator > _r;\n"
	   << "};\n\n";
    }

    _out << "template< typename F, typename C, typename Base, typename Generator,\n"
	 << "          int n = F::vars, int b = Base::vars >\n"
	 << "struct RandomGeneratorIndependentC { };\n\n";

    for ( int m = 2; m <= n; m ++ ) {
      combinations comb( 2, m );
      for( combinations::const_iterator c = comb.begin(); c != comb.end(); c++ ) {
	const vector<int> & v = *c;
	_out << "template< typename F, typename C, typename Base, typename Generator >\n"
	     << "struct RandomGeneratorIndependentC< F, C, Base, Generator, " 
	     << v[ 0 ] << ", " << v[ 1 ] << " > :\n"
	     << "  public Base,\n"
	     << "  public Arguments< ";
	list (  "typename F::arg", v[ 0 ] );
	_out << ", ";
	list (  "typename Base::Pdf::arg", v[ 1 ] );
	_out << " > {\n"
	     << "  enum { vars = F::vars + Base::Pdf::vars };\n"
	     << "  typedef Arguments< ";
	list (  "typename F::arg", v[ 0 ] );
	_out << ", ";
	list (  "typename Base::Pdf::arg", v[ 1 ] );
	_out << " > I;\n"
	     << "  RandomGeneratorIndependentC( const IndependentC< F, C > & f ) : \n"
	     << "    Base( f.ff() ), _r( f.f() ) { }\n"
	     << "  void generate( ";
	list2 ( "typename I::arg", m, " & x" );
	_out << " ) const\n"
	     << "  {\n"
	     << "    _r.generate( ";
	list  ( "x", v[ 0 ] );
	_out << " );\n"
	     << "    Base::generate( ";
	list  ( "x", v[ 0 ], v[ 0 ] + v[ 1 ] - 1 );
	_out << " );\n"
	     << "  }\n"
	     << "private:\n"
	     << "  RandomGenerator< F, Generator > _r;\n"
	     << "};\n\n";
      }
    }
        
    _out  << "template< typename F, typename Generator >\n"
	  << "struct RandomGenerator< Independent1< F >, Generator > :\n"
	  << "  public RandomGeneratorIndependent1< F, Generator > {\n"
	  << "  RandomGenerator( const Independent1< F >& f ) :\n"
	  << "    RandomGeneratorIndependent1< F, Generator >( f ) { }\n"
	  << "};\n\n";

    for ( int m = 2; m <= n; m ++ ) {
      _out << "template< ";
      list  ( "typename F", m );
      _out << ", typename Generator >\n"
	   << "struct RandomGenerator< Independent" << m << "< ";
      list  ( "F", m );
      _out <<" >, Generator > :\n"
	   << "  public RandomGeneratorIndependentC< F0, Independent" << m - 1 << "< ";
      list  ( "F", 1, m - 1 );
      _out << " >, \n"
	   << "                                      RandomGenerator< Independent" << m - 1 << "< ";
      list  ( "F", 1, m - 1 );
      _out << " >, Generator >,\n"
	   << "                                      Generator> {\n"
	   << "  typedef const Independent" << m << "< ";
      list  ( "F", m );
      _out << " > Pdf;\n"
	   << "  RandomGenerator( const Pdf& f ) :\n"
	   << "    RandomGeneratorIndependentC< F0, Independent" << m - 1 << "< ";
      list  ( "F", 1, m - 1 );
      _out << " >, \n"
	   << "                                 RandomGenerator< Independent" << m - 1 << "< ";
      list  ( "F", 1, m - 1 );
      _out << " >, Generator >,\n"
	   << "                                 Generator>\n"
	   << "      ( f ) { }\n"
	   << "};\n\n";
    }

    for ( int m = 1; m <= n; m ++ ) {
      _out << "template< ";
      list  ( "typename F", m );
      _out << ", typename Generator >\n"
	   << "struct RandomGenerator< Independent< ";
      list  ( "F", m );
      _out <<" >, Generator > :\n"
	   << "  public RandomGenerator< Independent" << m << "< ";
      list  ( "F", m );
      _out << " >, Generator > {\n"
	   << "  typedef const Independent< ";
      list  ( "F", m );
      _out << " > Pdf;\n"
	   << "  RandomGenerator( const Pdf& f ) :\n"
	   << "    RandomGenerator< Independent" << m << "< ";
      list  ( "F", m );
      _out << " > >\n"
	   << "      ( f ) { }\n"
	   << "};\n\n";
    }

    foot();
  }
};

int main( int argc, char ** argv ) {
  const char * header ="RandomGeneratorIndependent.h";
  if ( argc == 2 ) {
    cout << " generating header file " << header << endl;
    istringstream str( argv[ 1 ] );
    int n;
    str >> n;
    cout << " maximum numger of arguments for Pdf's is " << n << endl;

    ofstream file( header );

    makeHeader_RandomGeneratorIndependent( file, n );

    return 0;
  }
  
  cout << "usage: " << argv[ 0 ] << " <arg_max> \n"
       << "  <arg_max> : maximum number of pdf arguments" << endl;

  return 0;
}