/***************************************************************************
                          moveset_mod.cpp  -  description
                             -------------------
    begin                : Thu Jan  8 01:07:10 2004
    copyright            : (C) 2002 by Cavalli Andrea
    email                : cavalli@bioc.unizh.ch
**************************************************************************/
/***************************************************************************
 *                                                                         *
 *   This program 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.                                   *
 *                                                                         *
 ***************************************************************************/

#include <zeta/module.h>
#include <zeta/class.h>
#include <zeta/zextclass.h>
#include <zeta/zobj.hpp>

#include <molecules/molecules.h>
#include <moveset.h>
#include <moveset/bondrotation.h>
#include <moveset/translation.h>
#include <moveset/rotation.h>
#include <moveset/scramblemove.h>
#include <moveset/sidechainmover.h>
#include <moveset/backbonemover.h>
#include <moveset/localbbmover.h>
#include <moveset/hybridc19.h>
#include <moveset/caangle.h>
#include <moveset/seed.h>
#include <moveset/fragments.h>
#include <moveset/localfragment.h>
#include <metropolis/metropolis.h>
#include <coormanager/coormanager.h>

//#include <ff.h>
//#include <dcdstream.h>

using namespace Almost;

template<>
inline string to_string(const Molecules & molecules){
  return "<Molecules>";
}

template<>
inline string to_string(const MDB & mdb){
  return "<MDB>";
}

template<>
inline string to_string(const MoveSet<double> & ){
  return "<MoveSet>";
}

template<typename float_type>
inline string to_string(const MoveSet<float_type> & ){
  return "<MoveSet>";
}


template<>
inline string to_string(const BondRotation<double> & ){
  return "<BondRotation>";
}


template<typename float_type>
inline string to_string(const BondRotation<float_type> & ){
  return "<BondRotation>";
}

template<>
inline string to_string(const Translation<double> & ){
  return "<Translation>";
}

template<>
inline string to_string(const Rotation<double> & ){
  return "<Rotation>";
}

template<>
inline string to_string(const ScrambleMove<double> & ){
  return "<Scramble>";
}


template<>
inline string to_string(const Seed<double> & ){
  return "<Seed>";
}

template<>
inline string to_string(const Fragment<double> & ){
  return "<Fragment>";
}

template<>
inline string to_string(const LocalFragment<double,3> & ){
  return "<LocalFragment>";
}

template<>
inline string to_string(const LocalFragment<double,9> & ){
  return "<LocalFragment>";
}

template<>
inline string to_string(const Fragment9<double> & ){
  return "<Fragment9>";
}


template<>
inline string to_string(const SideChainMover<double> & ){
  return "<SideChain>";
}

template<>
inline string to_string(const BackBoneMover<double> & ){
  return "<BackBone>";
}

template<>
inline string to_string(const LocalBBMover<double> & ){
  return "<LocalBB>";
}

template<>
inline string to_string(const HybridC19<double> & ){
  return "<HybridC19>";
}

template<>
inline string to_string(const CaAngle<double> & ){
  return "<CaAngle>";
}


template<>
inline string to_string(const Coor<double> & ){
  return "<Coor>"; 
}


// inline string to_string(const DCDOStream & ){
//   return "<dcdostream>"; 
// }


// Coor<double> mols_coor(const Molecules & molecules){
//   Coor<double> coor;
//   coor.resize(molecules.atom_size());
//   for(int i=0; i<molecules.atom_size();i++){
//     coor.X[i] = molecules[i][0];
//     coor.Y[i] = molecules[i][1];
//     coor.Z[i] = molecules[i][2];
//   }
//   return coor;
// }
    

void test_local(Molecules & molecules, 
		LocalFragment<double,9> & frag9){

  Coor<double> coor(molecules);
  frag9.apply(coor);

  for(int i=0;i<molecules.atom_size();i++)
    for(int j=0;j<3;j++)
      molecules[i][j]=coor[i][j];
}

extern "C" {
  void init_moveset(){
    //declarations here

    Module mod = Module("moveset","Monte Carlo moveset");

    Class<MoveSet<double>,ArgList1<const Molecules &> >(mod.self(),"moveset")
      .def_method("add_translation",
		  &MoveSet<double>::add_translation)
      .def_method("add_rotation",
		  &MoveSet<double>::add_rotation)
      .def_method("add_backbone",
		  &MoveSet<double>::add_backbone)
      .def_method("add_localbb",
		  &MoveSet<double>::add_localbb)
      .def_method("add_sidechain",
		  &MoveSet<double>::add_sidechain)
      .def_method("add_scramble",
		  &MoveSet<double>::add_scramble)
      .def_method("add_hybridc19",
		  &MoveSet<double>::add_hybridc19)
      .def_method("add_seed",
		  &MoveSet<double>::add_seed)
      .def_method("add_fragment",
		  &MoveSet<double>::add_fragments)
      .def_method("add_fragment9",
		  &MoveSet<double>::add_fragments9)
      .def_method("add_caangle",
		  &MoveSet<double>::add_caangle)
      .def_method("clear",&MoveSet<double>::clear);


    typedef void (BondRotation<double>::*Applay_Coor)(Coor<double> & coor,
						      double angle, 
						      int code,
						      bool right) const; 

    typedef void (BondRotation<double>::*Applay_Vect)(vector<double*> & coor,
						      double angle, 
						      int code,
						      bool right) const;

    Applay_Coor applay_coor = &BondRotation<double>::apply;
    Applay_Vect applay_Vect = &BondRotation<double>::apply;

    Class<BondRotation<double>,ArgList2<const Molecules &,bool> >(mod.self(),
								  "bond_rotation")
      .def_method("apply",applay_coor)
      .def_method("apply_vect",applay_coor);
    //      .def_method("set_dihedral",&BondRotation<double>::set_dihedral);


    Class<Translation<double>,ArgList5<
      const Molecules & , int ,
      double,
      int, 
      int> >(mod.self(),"translation"); 

    Class<Rotation<double>,ArgList5<
      const Molecules & , int ,
      double,
      int, 
      int> >(mod.self(),"rotation"); 

    Class<ScrambleMove<double>,ArgList5<
      const Molecules & , int ,
      double,
      int, 
      int> >(mod.self(),"scramble"); 

    Class<SideChainMover<double>,ArgList6<
      const Molecules & , int ,
      const BondRotation<double> &,
      double,
      int, 
      int> >(mod.self(),"sidechain"); 

    Class<BackBoneMover<double>,ArgList5<
      const Molecules & , 
      const BondRotation<double> &,
      double,
      int, 
      int> >(mod.self(),"backbone"); 

    Class<Seed<double>,ArgList3<
      const Molecules & , 
      const BondRotation<double> &,
      string> >(mod.self(),"seed"); 

    Class<Fragment<double>,ArgList4<
      const Molecules & , 
      const BondRotation<double> &,
      int,
      string> >(mod.self(),"fragment"); 

    Class<Fragment9<double>,ArgList4<
      const Molecules & , 
      const BondRotation<double> &,
      int,
      string> >(mod.self(),"fragment9"); 

Class<LocalFragment<double,3>,ArgList4<
      const Molecules & , 
      const BondRotation<double> &,
      int,
      string> >(mod.self(),"local_fragment"); 

Class<LocalFragment<double,9>,ArgList4<
      const Molecules & , 
      const BondRotation<double> &,
      int,
      string> >(mod.self(),"local_fragment9")
  .def_method("add_range",&LocalFragment<double,9>::add_range)
  ; 


    Class<LocalBBMover<double>,ArgList6<
      const Molecules & , 
      const BondRotation<double> &,
      double,
      double,
      int,
      int> >(mod.self(),"local")
      .def_method<int (LocalBBMover<double>::*)(Coor<double> &) >("apply",&LocalBBMover<double>::apply)
      .def_method("asym",&LocalBBMover<double>::asym)
      .def_method("dw",&LocalBBMover<double>::torsions_incr)
      ;
  
//     Class<HybridC19<double>,ArgList2<const Molecules &,
//       const HybridC19Options<double> & > >(mod.self(),"hybridc19");

//     Class<HybridC19Options<double> >(mod.self(),"c19_options")
//       .def_attribute("rdie",&HybridC19Options<double>::rdie)
//       .def_attribute("solv",&HybridC19Options<double>::solv)
//       .def_attribute("solv_ignore_h",&HybridC19Options<double>::solv_ignore_h)
//       .def_attribute("vdw_shift",&HybridC19Options<double>::vdw_shift)
//       .def_attribute("elec_shift",&HybridC19Options<double>::elec_shift)
//       .def_attribute("cut_on",&HybridC19Options<double>::cut_on)
//       .def_attribute("cut_off",&HybridC19Options<double>::cut_off)
//       .def_attribute("cut_nb",&HybridC19Options<double>::cut_nb)
//       .def_attribute("e_zero",&HybridC19Options<double>::e_zero)
//       .def_attribute("e_14",&HybridC19Options<double>::e_14)
//       .def_attribute("eps",&HybridC19Options<double>::eps)
//       .def_attribute("r_water",&HybridC19Options<double>::r_water)
//       .def_attribute("const_file",&HybridC19Options<double>::const_file)
//       .def_attribute("shake_mode",&HybridC19Options<double>::shake_mode)
//       .def_attribute("shake_tol",&HybridC19Options<double>::shake_tol)
//       .def_attribute("vect",&HybridC19Options<double>::vect)
//       .def_attribute("temp",&HybridC19Options<double>::temp)
//       .def_attribute("time_step",&HybridC19Options<double>::time_step)
//       .def_attribute("nsteps",&HybridC19Options<double>::nsteps)
//       .def_attribute("nupdate",&HybridC19Options<double>::nupdate)
//       .def_attribute("seed",&HybridC19Options<double>::seed);


//     Class<Coor<double> >(mod.self(),"coor")
//       .def_method("copy",&Coor<double>::copy);

//     Class<DCDOStream,ArgList1<string> >(mod.self(),"dcdostream")
//       .def_method("close",&DCDOStream::close)
//       .def_method("write",&DCDOStream::write);
    
//     mod.def_function("mols_coor","Return a Coor structure with the coordinates of the molecule.",mols_coor);  


     mod.def_function("test_local","Computes mead torsion increment for local backbone moves.",test_local);
  }

  


}