/***************************************************************************
                          swissprot_mod.cpp  -  description
                             -------------------
    begin                : Thu Jan 11 10:09:01 2007
    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 <module.h>
#include <class.h>
#include <zextclass.h>
#include <zobj.hpp>
#include <boost/iostreams/filtering_streambuf.hpp>
#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/copy.hpp>
#include <boost/iostreams/filter/gzip.hpp>
#include <boost/iostreams/filter/bzip2.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/classification.hpp>
#include <stdio.h>
#include <sqlite3.h>
using namespace Almost;

class SwissProt {
  //Data
  enum { REVIEWD, UNREVIEWD };
  struct SpEntry {
    string id;
    string acc;
    bool data_class;
    int length;
    string gn;
    string os;
    string oc;
    string ox;
    string rx;
    vector<string> dr;
    string seq_desc;
    string seq;
  };

  vector<SpEntry> sp;
public:
  SwissProt(){};
  int parse(string file){
    int comp = 0;
    int len = file.size()-1;
    if(file[len]=='z'&&file[len-1]=='g')
      comp =1;
    if(file[len]=='2'&&file[len-1]=='z'&&file[len-2]=='b')
      comp=2;
    if(comp==0){
      ifstream in;
      in.open(file.c_str());
      if(!in){
	cout<<"FATAL ERROR: no such file: "<<file<<endl;
	exit(-1);
      }
      read(in);
      in.close();
    }
    if(comp==1){
      ifstream in;
      in.open(file.c_str(),ios_base::in | ios_base::binary);
      boost::iostreams::filtering_istream in_gz;
      in_gz.push(boost::iostreams::gzip_decompressor());
      in_gz.push(in);
      read(in_gz);
      in.close();
    }
    if(comp==2){
      ifstream in;
      in.open(file.c_str(),ios_base::in | ios_base::binary);
      boost::iostreams::filtering_istream in_bz2;
      in_bz2.push(boost::iostreams::bzip2_decompressor());
      in_bz2.push(in);
      read(in_bz2);
      in.close();
    }
    return 1;
  }

  void create_db(string n){
    sqlite3 *db;
    char *zErrMsg = 0;
    int rc;
    rc = sqlite3_open(n.c_str(), &db);
    if( rc ){
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      sqlite3_close(db);
      exit(1);
    }

    //Create tables
    {
      string c = "create table swissprot ( accession varchar(20), id varchar(20), sequence text);";

      rc = sqlite3_exec(db, c.c_str(), 0, 0, &zErrMsg);
      if( rc!=SQLITE_OK ){
	fprintf(stderr, "SQL error: %s\n", zErrMsg);
	sqlite3_free(zErrMsg);
      }else {
	for(int i=0;i<sp.size();i++){
	  stringstream c;
	  c <<"INSERT INTO swissprot VALUES(";
	  c <<"'"<<sp[i].acc<<"'"
	    <<",'"<<sp[i].id<<"'"
	    <<",'"<<sp[i].seq<<"');";
	  sqlite3_exec(db, c.str().c_str(), 0, 0, &zErrMsg);
	  if( rc!=SQLITE_OK ){
	    fprintf(stderr, "SQL error: %s\n", zErrMsg);
	    sqlite3_free(zErrMsg);
	  }
	}
      }

      c = "create table spx ( accession varchar(20), db varchar(20), id1 text, id2 text, id3 text, id4 text );";

      rc = sqlite3_exec(db, c.c_str(), 0, 0, &zErrMsg);
      if( rc!=SQLITE_OK ){
	fprintf(stderr, "SQL error: %s\n", zErrMsg);
	sqlite3_free(zErrMsg);
      }else {
	for(int i=0;i<sp.size();i++){
	  for(int j=0;j<sp[i].dr.size();j++){
	    vector<string> tok;
	    boost::split(tok,sp[i].dr[j],boost::is_any_of(" "));
	    while(tok.size()<5) tok.push_back("-");
	    stringstream c;
	    c <<"INSERT INTO spx VALUES(";
	    c <<"'"<<sp[i].acc<<"',";
	    c <<"'"<<string(tok[0].begin(),tok[0].end()-1)<<"',";
	    c <<"'"<<string(tok[1].begin(),tok[1].end()-1)<<"',";
	    c <<"'"<<string(tok[2].begin(),tok[2].end()-1)<<"',";
	    c <<"'"<<string(tok[3].begin(),tok[3].end()-1)<<"',";
	    c <<"'"<<string(tok[4].begin(),tok[4].end()-1)<<"');";
	    sqlite3_exec(db, c.str().c_str(), 0, 0, &zErrMsg);
	    if( rc!=SQLITE_OK ){
	      fprintf(stderr, "SQL error: %s\n", zErrMsg);
	      sqlite3_free(zErrMsg);
	    }
	  }
	}
      }

    }
    sqlite3_close(db);
  }
private:
  void gn_line(SpEntry & sp_entry,const string &l){
    sp_entry.gn += string(l.begin()+2,l.end());      
  }

  void os_line(SpEntry & sp_entry,const string &l){
    sp_entry.os += string(l.begin()+2,l.end());      
  }

  void oc_line(SpEntry & sp_entry,const string &l){
    sp_entry.oc += string(l.begin()+2,l.end());      
  }

  void ox_line(SpEntry & sp_entry,const string &l){
    sp_entry.ox += string(l.begin()+2,l.end());      
  }

  void rx_line(SpEntry & sp_entry,const string &l){
    sp_entry.rx += string(l.begin()+2,l.end());      
  }

  void sq_line(SpEntry & sp_entry,const string &l){
    sp_entry.seq_desc += string(l.begin()+2,l.end());      
  }

  void dr_line(SpEntry & sp_entry,const string &l){
    string l_local;
    int size = l.size();
    //    l_local.push_back(l[0]);
    int last = 0;
    for(int i=5;i<size;i++)
      if(!(l[i]==' '&&l[i]==l_local[last])){
	l_local.push_back(l[i]);
	++last;
      }
    sp_entry.dr.push_back(l_local);    
  }

  void id_line(SpEntry & sp_entry,const string &l){
    string l_local;
    int size = l.size();
    l_local.push_back(l[0]);
    int last = 0;
    for(int i=1;i<size;i++)
      if(!(l[i]==' '&&l[i]==l_local[last])){
	l_local.push_back(l[i]);
	++last;
      }
    vector<string> tok;
    boost::split(tok,l_local,boost::is_any_of(" "));
    sp_entry.id = tok[1];
    if(tok[2]=="Reviewed;") sp_entry.data_class = true;
    else sp_entry.data_class = false;
    sp_entry.length = atoi(tok[3].c_str());
  }

  void ac_line(SpEntry & sp_entry,const string &l){
    string l_local;
    int size = l.size();
    l_local.push_back(l[0]);
    int last = 0;
    for(int i=1;i<size;i++)
      if(!(l[i]==' '&&l[i]==l_local[last])){
	l_local.push_back(l[i]);
	++last;
      }
    vector<string> tok;
    boost::split(tok,l_local,boost::is_any_of(" "));
    sp_entry.acc = string(tok[1].begin(),tok[1].end()-1);
  }

  void read(istream &in){
    int count = 0;
    SpEntry sp_entry;
    while(in){
      string l;
      getline(in,l,'\n');

      string keyword = string(l.begin(),l.begin()+2);
      //DT DE OG OH skipped. Only RX in cit. CC KW FT skipped
      if(keyword=="ID"){
	id_line(sp_entry,l);
      }
      else if(keyword=="AC"){
	ac_line(sp_entry,l);
      }      
      else if(keyword=="GN"){
	gn_line(sp_entry,l);
      }
      else if(keyword=="OS"){
	os_line(sp_entry,l);
      }
      else if(keyword=="OC"){
	oc_line(sp_entry,l);
      }
      else if(keyword=="OX"){
	ox_line(sp_entry,l);
      }
      else if(keyword=="RX"){
	rx_line(sp_entry,l);
      }
      else if(keyword=="DR"){
	dr_line(sp_entry,l);
      }
      else if(keyword=="SQ"){
	sq_line(sp_entry,l);
      }
      else if(keyword=="  "){
	if(sp_entry.seq_desc.size()!=0){
	  sp_entry.seq += string(l.begin()+5,l.end());
	}
      }
      else if(keyword=="//"){
	sp.push_back(sp_entry);
	sp_entry = SpEntry();
	cout<<++count<<" "<<sp.back().id<<" "<<sp.back().data_class<<" "
	    <<sp.back().length<<" "
	    <<sp.back().gn<<" "
	    <<sp.back().os<<" "
	    <<sp.back().oc<<" "
	    <<sp.back().ox<<" "
	    <<sp.back().rx<<" "
	    <<endl;
	for(int i=0;i<sp.back().dr.size();i++)
	  cout<<"\t"<<sp.back().dr[i]<<"\n";
	//Trimm seq
	{
	  int size = sp.back().seq.size();
	  string s;
	  for(int i=0;i<size;i++){
	    if(sp.back().seq[i]!=' ') 
	      s += sp.back().seq[i];
	  }
	  sp.back().seq = s; 
	  cout<<"\t>"<<sp.back().seq.size()<<" "<<sp.back().seq<<"\n";
	}
// 	if(count==1000){
// 	  cout<<"DEBU 1000"<<endl;
// 	  return;
// 	}
      }
    }
  }
};

template<>
inline string to_string(const SwissProt &){
  return "<swissprot>";
}

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

    Module mod = Module("swissprot");
    Class<SwissProt>(mod.self(),"swissprot")
      .def_method("parse",&SwissProt::parse)
      .def_method("create_db",&SwissProt::create_db)
      ;

  }
}