/***************************************************************************
                          mdb_mod.cpp  -  description
                             -------------------
    begin                : Tue Mar 18 18:15:13 2003
    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 <almosttypes.h>
#include <almosttemplate.h>
#include <mdb/mdb.h>
#include <zeta/module.h>
#include <zeta/class.h>
#include <zeta/zextclass.h>
#include <zeta/tostring.h>
#include <zeta/zobj.hpp>


namespace Almost {
  const string c19_eef1_str = "all19_eef1.mdb";
  const string c22_str = "all22.mdb";
}


using namespace Almost;

template<>
inline string to_string(const AtomT & atom){
  return atom.to_string();
}

template<>
inline string to_string(const BondT & bond){
  return bond.to_string();
}

template<>
inline string to_string(const AngleT & angle){
  return angle.to_string();
}

template<>
inline string to_string(const DihedralT & dihedral){
  return dihedral.to_string();
}

template<>
inline string to_string(const ImproperT & improper){
  return improper.to_string();
}

template<>
inline string to_string(const NBondT & nbond){
  return nbond.to_string();
}

template<>
inline string to_string(const SasaT & sasa){
  return sasa.to_string();
}

template<>
inline string to_string(const TAtom & tatom){
  return tatom.to_string(false,true);
}

template<>
inline string to_string(const TBond & tbond){
  return tbond.to_string();
}

template<>
inline string to_string(const TDihedral & tdihedral){
  return tdihedral.to_string();
}

template<>
inline string to_string(const TImproper & timproper){
  return timproper.to_string();
}

template<>
inline string to_string(const TIC & tic){
  return "<tic>";
}

template<>
inline string to_string(const TGroup & gr){
  return "<group>";
}

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

template<>
inline string to_string(const TemplateFragment & tf){
  stringstream strout;
  FormOStream fout(strout);  
  fout<<tf;
  return strout.str();
}

template<>
inline string to_string(const TemplatePatch & tf){
  return "<Template Patch>";
}



void write_mdb(string file, const Almost::MDB &mdb){
  ofstream out;
  out.open(file.c_str());
  {
    FormOStream f(out);
    f<<mdb;
  }
  out.close();
}

void normalize_ic(Almost::MDB &mdb){
  map<string,TemplateFragment>::iterator iter = mdb.fragment_begin(),
    end = mdb.fragment_end();

  while(iter!=end){
    cout<<"DEB NORM "<<iter->first<<endl;
    vector<TIC>::iterator tic_iter = iter->second.ic_begin(),
      tice = iter->second.ic_end();
    while(tic_iter!=tice){
      for(int i=0;i<5;i++){
	if(i!=2)
	  tic_iter->set_data(i,0);
	else {
	  double d = tic_iter->data(2);
	  if(d>170.0) tic_iter->set_data(2,180.0);
	  else if(d>110.0&&d<130.0) tic_iter->set_data(2,120.0);
	  else if(d<-110.0&&d>-130.0) tic_iter->set_data(2,-120.0);
	  else if(d>80.0&&d<100.0) tic_iter->set_data(2,90.0);
	  else if(d<-80.0&&d>-100.0) tic_iter->set_data(2,-90.0);
	  else if(d<-170) tic_iter->set_data(2,-170.0);
	  else if(d>-10&&d<10) tic_iter->set_data(2,0.0);
	  else cout<<"DEB "<<d<<endl;
	}
      }

      ++tic_iter;
    }
    ++iter;
  }

  // write_mdb("norm.mdb",mdb);
}



void init_mdb_types(ZModule & module){
  
  //class AtomT
  Class<AtomT>(module,"AtomT")
    .def_method("name",&AtomT::name)
    .def_method("mass",&AtomT::mass)
    .def_method("chem",&AtomT::chem)
    .def_method("hybridization",&AtomT::hybridization)
    .def_method("set_name",&AtomT::set_name)
    .def_method("set_mass",&AtomT::set_mass)
    .def_method("set_chem",&AtomT::set_chem)
    .def_method("set_hybridization",&AtomT::set_hybridization);

  //class BondT
  Class<BondT>(module,"BondT")
    .def_method("first",&BondT::first)
    .def_method("second",&BondT::second)
    .def_method("atom",&BondT::atom)
    .def_method("name",&BondT::name)
    .def_method("bond_const",&BondT::bond_const)
    .def_method("equ_length",&BondT::equ_length)
    .def_method("set_first",&BondT::set_first)
    .def_method("set_second",&BondT::set_second)
    .def_method("set_bond_const",&BondT::set_bond_const)
    .def_method("set_equ_length",&BondT::set_equ_length);

  //class AngleT
  Class<AngleT>(module,"AngleT")
    .def_method("angle_const",&AngleT::angle_const)
    .def_method("equ_angle",&AngleT::equ_angle)
    .def_method("has_ub",&AngleT::has_ub)
    .def_method("ub_angle_const",&AngleT::ub_angle_const)
    .def_method("ub_equ_angle",&AngleT::ub_equ_angle)
    .def_method("atom",&AngleT::atom)
    .def_method("name",&AngleT::name)
    .def_method("set_angle_const",&AngleT::set_angle_const)
    .def_method("set_equ_angle",&AngleT::set_equ_angle)
    .def_method("set_ub_angle_const",&AngleT::set_ub_angle_const)
    .def_method("set_ub_equ_angle",&AngleT::set_ub_equ_angle)
    .def_method("set_atom",&AngleT::set_atom)
    .def_method("set_has_ub",&AngleT::set_has_ub);
    
  //class DihedralT
  Class<DihedralT>(module,"DihedralT")
    .def_method("dihe_const",&DihedralT::dihe_const)
    .def_method("n",&DihedralT::n)
    .def_method("delta",&DihedralT::delta)
    .def_method("atom",&DihedralT::atom)
    .def_method("set_dihe_const",&DihedralT::set_dihe_const)
    .def_method("set_n",&DihedralT::set_n)
    .def_method("set_delta",&DihedralT::set_delta)
    .def_method("set_atom",&DihedralT::set_atom);

  //class ImproperT
  Class<ImproperT>(module,"ImproperT")
    .def_method("imph_const",&ImproperT::imph_const)
    .def_method("n",&ImproperT::n)
    .def_method("equ_angle",&ImproperT::equ_angle)
    .def_method("atom",&ImproperT::atom)
    .def_method("set_imph_const",&ImproperT::set_imph_const)
    .def_method("set_n",&ImproperT::set_n)
    .def_method("set_equ_angle",&ImproperT::set_equ_angle)
    .def_method("set_atom",&ImproperT::set_atom);

  //class NBondT
  Class<NBondT>(module,"NBondT")
    .def_method("atom",&NBondT::atom)
    .def_method("sigma",&NBondT::sigma)
    .def_method("emin",&NBondT::emin)
    .def_method("sigma14",&NBondT::sigma14)
    .def_method("emin14",&NBondT::emin14)
    .def_method("set_atom",&NBondT::set_atom)
    .def_method("set_sigma",&NBondT::set_sigma)
    .def_method("set_emin",&NBondT::set_emin)
    .def_method("set_sigma14",&NBondT::set_sigma14)
    .def_method("set_emin14",&NBondT::set_emin14);

  //class SasaT
  Class<SasaT>(module,"SasaT")
    .def_method("atom",&SasaT::atom)
    .def_method("solv",&SasaT::solv)
    .def_method("vdw",&SasaT::vdw)
    .def_method("atom_par",&SasaT::atom_par)
    .def_method("set_atom",&SasaT::set_atom)
    .def_method("set_solv",&SasaT::set_solv)
    .def_method("set_vdw",&SasaT::set_vdw)
    .def_method("set_atom_par",&SasaT::set_atom_par);

  //class TAtom
  Class<TAtom,ArgList3<string,string,double> >(module,"TAtom")
    .def_method("set_charge",&TAtom::set_charge)
    .def_method("set_name",&TAtom::set_name)
    .def_method("set_type_name",&TAtom::set_type_name)
    .def_method("add_exclusion_list",&TAtom::add_exclusion_list)
    .def_method("erase_exlusion_list",&TAtom::erase_exlusion_list)
    .def_method("is_excluded",&TAtom::is_excluded)
    .def_method("name",&TAtom::name)
    .def_method("charge",&TAtom::charge)
    .def_method("type_name",&TAtom::type_name)
    .def_method("exclusion_list",&TAtom::exclusion_list);

  Class<vector<TAtom> >("TAtomvect")
    .def_method("push_back",&vector<TAtom>::push_back)
    .def_method("size",&vector<TAtom>::size)
    .def_method("clear",&vector<TAtom>::clear)
    //      .def_method("resize",&vector<float>::resize)
    ;
  
  ZObj::BinaryOperator<INDEX>::add_ifndef<vector<TAtom>,int>
    (index_operator<vector<TAtom> ,int,TAtom &>);

  //class TBond
  Class<TBond,ArgList2<string,string> >(module,"TBond")
    .def_method("set_atom",&TBond::set_atom)
    .def_method("set_first",&TBond::set_first)
    .def_method("set_second",&TBond::set_second)
    .def_method("atom",&TBond::atom)
    .def_method("first",&TBond::first)
    .def_method("second",&TBond::second)
    .def_method("is_atom",&TBond::is_atom)
    .def_method("is_first",&TBond::is_first)
    .def_method("is_second",&TBond::is_second);

  Class<vector<TBond> >("TBondvect")
    .def_method("push_back",&vector<TBond>::push_back)
    .def_method("size",&vector<TBond>::size)
    .def_method("clear",&vector<TBond>::clear)
    //      .def_method("resize",&vector<float>::resize)
    ;


  ZObj::BinaryOperator<INDEX>::add_ifndef<vector<TBond>,int>
    (index_operator<vector<TBond> ,int,TBond &>);


  //class TDihedral
  Class<TDihedral,ArgList4<string,string,string,string> >(module,"TDihedral")
    .def_method("set_atom",&TDihedral::set_atom)
    .def_method("atom",&TDihedral::atom)
    .def_method("is_atom",&TDihedral::is_atom);

  Class<vector<TDihedral> >("TDihedralvect")
    .def_method("push_back",&vector<TDihedral>::push_back)
    .def_method("size",&vector<TDihedral>::size)
    .def_method("clear",&vector<TDihedral>::clear)
    //      .def_method("resize",&vector<float>::resize)
    ;


  ZObj::BinaryOperator<INDEX>::add_ifndef<vector<TDihedral>,int>
    (index_operator<vector<TDihedral> ,int,TDihedral &>);


  //class TImproper
  Class<TImproper,ArgList4<string,string,string,string> >(module,"TImproper")
    .def_method("set_atom",&TImproper::set_atom)
    .def_method("atom",&TImproper::atom)
    .def_method("is_atom",&TImproper::is_atom);

  Class<vector<TImproper> >("TImpropervect")
    .def_method("push_back",&vector<TImproper>::push_back)
    .def_method("size",&vector<TImproper>::size)
    .def_method("clear",&vector<TImproper>::clear)
    //      .def_method("resize",&vector<float>::resize)
    ;


  ZObj::BinaryOperator<INDEX>::add_ifndef<vector<TImproper>,int>
    (index_operator<vector<TImproper> ,int,TImproper &>);

  Class<TIC>(module,"TIC")
    .def_method("set_atom",&TIC::set_atom)
    .def_method("atom",&TIC::atom)
    .def_method("set_data",&TIC::set_data)
    .def_method("data",&TIC::data)
    ;

  Class<vector<TIC> >("TICvect")
    .def_method("push_back",&vector<TIC>::push_back)
    .def_method("size",&vector<TIC>::size)
    .def_method("clear",&vector<TIC>::clear)
    //      .def_method("resize",&vector<float>::resize)
    ;


  ZObj::BinaryOperator<INDEX>::add_ifndef<vector<TIC>,int>
    (index_operator<vector<TIC> ,int,TIC &>);

  //class TemplateFragment
  Class<TemplateFragment, ArgList3<string,double,int> >(module,"TemplateFragment")
    .def_method("set_name",&TemplateFragment::set_name)
    .def_method("set_charge",&TemplateFragment::set_charge)
    .def_method("set_patch",&TemplateFragment::set_patch)
    .def_method<void (TemplateFragment::*)(string)>("set_kind",&TemplateFragment::set_kind)
    .def_method("set_first_def_patch",&TemplateFragment::set_first_def_patch)
    .def_method("set_last_def_patch",&TemplateFragment::set_last_def_patch)
    .def_method("name",&TemplateFragment::name)
    .def_method("charge",&TemplateFragment::charge)
    .def_method("kind",&TemplateFragment::kind)
    .def_method("def_patch",&TemplateFragment::def_patch)
    .def_method("def_first_patch",&TemplateFragment::def_first_patch)
    .def_method("def_last_patch",&TemplateFragment::def_last_patch)
    .def_method("patched",&TemplateFragment::patched)
    .def_method("first_patched",&TemplateFragment::first_patched)
    .def_method("last_patched",&TemplateFragment::last_patched)
    .def_method("atoms",&TemplateFragment::atoms)
    .def_method("bonds",&TemplateFragment::bonds)
    .def_method("dihedrals",&TemplateFragment::dihedrals)
    .def_method("impropers",&TemplateFragment::impropers)
    .def_method("groups",&TemplateFragment::groups)
    .def_method("ics",&TemplateFragment::ics)
    .def_method<void (TemplateFragment::*)(TAtom)>("push_back_atom",&TemplateFragment::push_back_atom)
    .def_method("erase_atom",&TemplateFragment::erase_atom)
    .def_method("atom_size",&TemplateFragment::atom_size)
    .def_method<void (TemplateFragment::*)(TBond)>("push_back_bond",&TemplateFragment::push_back_bond)
    .def_method("erase_bond",&TemplateFragment::erase_bond)
    .def_method("bond_size",&TemplateFragment::bond_size)
    .def_method<void (TemplateFragment::*)(TDihedral)>("push_back_dihedral",&TemplateFragment::push_back_dihedral)
    .def_method("erase_dihedral",&TemplateFragment::erase_dihedral)
    .def_method("dihedral_size",&TemplateFragment::dihedral_size)
    .def_method<void (TemplateFragment::*)(TIC)>("push_back_ic",&TemplateFragment::push_back_ic)
    .def_method<void (TemplateFragment::*)(TImproper)>("push_back_improper",&TemplateFragment::push_back_improper)
    .def_method("erase_improper",&TemplateFragment::erase_improper)
    .def_method("improper_size",&TemplateFragment::improper_size)
    .def_method("patch_first",&TemplateFragment::patch_first)
    .def_method("patch_last",&TemplateFragment::patch_last);

  //class TemplatePatch
  Class<TemplatePatch, ArgList3<string,double,int> >(module,"TemplatePatch")
    .def_method("set_name",&TemplatePatch::set_name)
    .def_method("set_charge",&TemplatePatch::set_charge)
    .def_method("name",&TemplatePatch::name)
    .def_method("charge",&TemplatePatch::charge)
    .def_method("kind",&TemplatePatch::kind)
    .def_method<void (TemplatePatch::*)(string)>("set_kind",&TemplatePatch::set_kind)
    .def_method("atoms",&TemplatePatch::atoms)
    .def_method("bonds",&TemplatePatch::bonds)
    .def_method("dihedrals",&TemplatePatch::dihedrals)
    .def_method("impropers",&TemplatePatch::impropers)
    .def_method<void (TemplatePatch::*)(TAtom)>("push_back_atom",&TemplatePatch::push_back_atom)
    .def_method("erase_atom",&TemplatePatch::erase_atom)
    .def_method("atom_size",&TemplatePatch::atom_size)
    .def_method<void (TemplatePatch::*)(TBond)>("push_back_bond",&TemplatePatch::push_back_bond)
    .def_method("erase_bond",&TemplatePatch::erase_bond)
    .def_method("bond_size",&TemplatePatch::bond_size)
    .def_method<void (TemplatePatch::*)(TDihedral)>("push_back_dihedral",&TemplatePatch::push_back_dihedral)
    .def_method("erase_dihedral",&TemplatePatch::erase_dihedral)
    .def_method("dihedral_size",&TemplatePatch::dihedral_size)
    .def_method<void (TemplatePatch::*)(TImproper)>("push_back_improper",&TemplatePatch::push_back_improper)
    .def_method("erase_improper",&TemplatePatch::erase_improper)
    .def_method("improper_size",&TemplatePatch::improper_size)
    .def_method("del_atoms",&TemplatePatch::del_atoms)
    .def_method("del_bonds",&TemplatePatch::del_bonds)
    .def_method("del_dihedrals",&TemplatePatch::del_dihedrals)
    .def_method("del_impropers",&TemplatePatch::del_impropers)
    .def_method("push_back_del_atom",&TemplatePatch::push_back_del_atom)
    .def_method("erase_del_atom",&TemplatePatch::erase_del_atom)
    .def_method("del_atom_size",&TemplatePatch::del_atom_size)
    .def_method("push_back_del_bond",&TemplatePatch::push_back_del_bond)
    .def_method("erase_del_bond",&TemplatePatch::erase_del_bond)
    .def_method("del_bond_size",&TemplatePatch::del_bond_size)
    .def_method("push_back_del_dihedral",&TemplatePatch::push_back_del_dihedral)
    .def_method("erase_del_dihedral",&TemplatePatch::erase_del_dihedral)
    .def_method("push_back_del_improper",&TemplatePatch::push_back_del_improper)
    .def_method("erase_del_improper",&TemplatePatch::erase_del_improper);


  //class MDB
  Class<MDB,ArgList1<const char *> >(module,"MDB")
    .def_method("fragment",&MDB::fragment)
    .def_method("patch",&MDB::patch)
    .def_method("atomT",&MDB::atomT)
    .def_method("nbondT",&MDB::nbondT)
    .def_method("bondT",&MDB::bondT)
    .def_method("angleT",&MDB::angleT)
    .def_method("dihedralT",&MDB::dihedralT)
    .def_method("improperT",&MDB::improperT)
    .def_method("scale_vdw",&MDB::scale_vdw)
    .def_method("db_fragments",&MDB::db_fragments)
    .def_method("db_patches",&MDB::db_patches)
    .def_method("rename_db",&MDB::rename_db)
    .def_method("fingerprint",&MDB::fingerprint)
    .def_method("fingerprint_string",&MDB::fingerprint_string)
    .def_method("fingerprint_heavy",&MDB::fingerprint_heavy)
    .def_method("fingerprint_heavy_string",&MDB::fingerprint_heavy_string)
    .def_method("atom",&MDB::atom)
    ;

}

extern "C" {
  void init_mdb(){
    Module module("mdb","Molecular Database");
    module.def_function("write_mdb","Writes molecular database file",write_mdb);
    module.def_function("normalize_ic","Normalizes IC",normalize_ic);
    module.def_const("C19EEF1",Almost::c19_eef1_str);
    module.def_const("C22",Almost::c22_str);
    init_mdb_types(module.self());
  }
}