/////////////////////////////////////////////////////////////////////////////
///
/// match.cpp - smarts matcher w/ different modes
///         
///    default - all possible matches.  c1ccccc1 matches itself 12 ways.
///    usa - unique-sets-of-atoms matches.  c1ccccc1 matches Oc1ccccc1 once.
///    asym - non symmetrical matches.  Brc1ccccc1 matches Brc1cc(O)ccc1
///       2 ways but Brc1ccc(O)cc1 only 1 way.  c1ccccc1 matches
///       Oc1ccccc1 6 ways.
///     exph (can be used together with one of the above) - explicit H mode
///       Normally Hs are implicit so [#1] will not match.  Turn on 
///       exph and it will match all Hs.  Beware that smarts [H] does not
///       mean a hydrogen -- rather an atom with 1 H.
///         
/////////////////////////////////////////////////////////////////////////////
/// author: Jeremy Yang
/// date:  17 Feb 2004
/////////////////////////////////////////////////////////////////////////////
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include "openeye.h"
#include "oeplatform.h"
#include "oesystem.h"
#include "oechem.h"


using namespace std;
using namespace OEChem;
using namespace OESystem;

int ParseCommandLine(int argc, char* argv[]);

void Help(string msg)
{
  cerr << msg << endl
    <<"\t************************************************************"<<endl
    <<"\t| match [options] [<infile] [>outfile]                     |"<<endl
    <<"\t|     -i <INFILE>                                          |"<<endl
    <<"\t|     -ifmt    <FMT> (lowcase, e.g., smi,mdl)              |"<<endl
    <<"\t|     -o <OUTFILE>                                         |"<<endl
    <<"\t|     -ofmt    <FMT> (lowcase, e.g., smi,mdl)              |"<<endl
    <<"\t|     -smarts <SMARTS>                                     |"<<endl
    <<"\t|     -usa ... unique-setof-atoms matches                  |"<<endl
    <<"\t|     -asym ... non-symmetric matches                      |"<<endl
    <<"\t|     -exph ... explicit-H smarts                          |"<<endl
    <<"\t|     -maxmatches <N> ... match limit [1024]               |"<<endl
    <<"\t|     -nowarn ... supress warnings                         |"<<endl
    <<"\t|     -v .......  verbose                                  |"<<endl
    <<"\t|     -help                                                |"<<endl
    <<"\t************************************************************"<<endl;
  cerr << endl;
  exit(1);
}


static oemolistream ims;                    // input molstream
static oemolostream oms;                    // input molstream
static int usa=0;                           // unique-setof-atoms flag
static int asym=0;                          // asymmetric match flag
static int exph=0;                          // explicit H flag
static int maxmatches=0;                    // max matches
static int verbose=0;                       // verbose reporting
static int nowarn=0;                        // supress warnings
static int ifmt=0;                          // input format
static int ofmt=0;                          // output format
static int wegot_ifile=0;                   // we got infile flag
static int wegot_ofile=0;                   // we got outfile flag
static char *smarts=NULL;                   // query smarts

int main(int argc, char* argv[])
{
  OEPlatform::oeosstream oeerrs;       // output string stream
  OESubSearch pat;                     // search pattern
  OEIter<OEMolBase> mol;               // molecule iterator
  OEIter<OEMatchBase> match;           // match iterator
  OEIter<OEMatchPair<OEAtomBase> > mp; // matchpair iterator
  OEGraphMol targetmol;                // matched submol
  int i,j,k;                           // generic ints
  unsigned int loc;
  char buff[1024]="";                  // term input buffer
  string smi,errs;                     // returned strings
  vector<int> idxl;                    // vector of match symclasses for a mol
  vector<vector<int> > idxll;          // vector of idxl vectors
  vector<int> syms;                    // vector of symmetric match-ids
  int matchcount=0;                    // match count
  int hitcount=0;                      // hit count

  ParseCommandLine(argc,argv);

  if (!wegot_ifile) {
    ims.open();
    if (ifmt) ims.SetFormat(ifmt);
    else Help("Input fmt required w/ stdin.");
  }
  if (!wegot_ofile) {
    oms.open();
    if (!ofmt) ofmt=OEFormat::SMI;
    oms.SetFormat(ofmt);
  }

  if (!smarts)
  {
    printf("Enter smarts> ");
    cin.getline(buff,1023);
    buff[strlen(buff)]='\0';
    smarts=buff;
  }

  if (!pat.Init(smarts)) {
    fprintf(stderr,"bad smarts: \"%s\"\n",smarts);
    Help("");
  } else if (verbose) fprintf(stderr,"smarts ok: \"%s\"\n",smarts);

  if (maxmatches) {
    pat.SetMaxMatches(maxmatches);
    if (verbose) fprintf(stderr,"max matches set to %d.\n",maxmatches);
  }
  if (usa && verbose) fprintf(stderr,"usa mode on.\n");
  if (exph && verbose) fprintf(stderr,"explicit-H mode on.\n");
  if (asym && verbose) fprintf(stderr,"asymmetric mode on.\n");

  OEThrow.SetOutputStream(oeerrs);

  for (i=0,mol=ims.GetMolBases();mol;++mol)
  {
    ++i;
    idxll.clear();

    if (verbose)
    {
      OECreateCanSmiString(smi,mol);
      cerr << smi << " " << mol->GetTitle() << endl;
    }

    if (exph) OEAddExplicitHydrogens(mol);
    OEAssignHybridization(mol);
    OETriposAtomNames(mol);
    matchcount=0;
    if (asym) OEPerceiveSymmetry(mol);

    for (match=pat.Match(mol,usa);match;++match)
    {
      if (verbose)
        fprintf(stderr,"\t%smatch (%d): ",usa?"USA ":"",matchcount+1);
      idxl.clear();
      for (mp=match->GetAtoms();mp;++mp)
      {
        if (verbose) cerr << mp->target->GetName();
        idxl.push_back(mp->target->GetSymmetryClass());
      }
      idxll.push_back(idxl);
      ++matchcount;
      if (verbose)
      {
        OESubsetMol(targetmol,match);
        OECreateCanSmiString(smi,targetmol);
        cerr << "\t" << smi << endl;
        targetmol.Clear();
      } 
    } 
    if (asym)
    {
      ///////////////////////////////////////////////////////
      // Compare all matches for symmetric equivalence
      // Keep vector (syms) of unique redundant matches.
      ///////////////////////////////////////////////////////
      syms.clear();
      for (j=0;j<matchcount;++j)
      {
        for (k=0;k<j;++k)
        {
          if (idxll[j]==idxll[k])
          {
            fprintf(stderr,"\tsymmetrical match (%d~%d)\n",j+1,k+1);
            if (find(syms.begin(),syms.end(),j)==syms.end()) syms.push_back(j);
          }
        }
      }
      cerr<<"\tasymmetrical matches: "<<(matchcount-(int)syms.size())<<endl;
    }
    errs=oeerrs.str();
    if (!errs.empty())
    {
      loc = errs.find("Warning");
      if (!nowarn || loc==string::npos)
         cerr << "[mol " << i << "]: " << errs << endl;
       oeerrs.clear();
    }
    if (verbose) cerr << "\ttotal matches: " << matchcount <<endl;
    if (matchcount>0)
    {
      OEWriteMolecule(oms,mol);
      ++hitcount;
    }
  }
  cerr << i << " mols; " << hitcount << " hits" <<endl;
  return 0;
}

/////////////////////////////////////////////////////////////////////////////
int ParseCommandLine(int argc, char* argv[])
{
  string a;
  for (++argv;--argc;++argv)
  {
    a=*argv;
    if (a=="-i")
    {
      if (--argc==0) Help("ERROR: -i requires value.");
      if (!ims.open(*++argv))
        OEThrow.Error("Unable to open \"%s\".\n",*argv);
      wegot_ifile=1;
    }
    else if (a=="-ifmt")
    {
      if (--argc==0) Help("ERROR: -ifmt requires value.");
      if (!(ifmt=OEGetFileType(*++argv))) 
        OEThrow.Error("Unknown file type \"%s\".\n",*argv);
    }
    else if (a=="-o")
    {
      if (--argc==0) Help("ERROR: -o requires value.");
      if (!oms.open(*++argv))
        OEThrow.Error("Unable to open \"%s\".\n",*argv);
      wegot_ofile=1;
    }
    else if (a=="-ofmt")
    {
      if (--argc==0) Help("ERROR: -ofmt requires value.");
      if (!(ofmt=OEGetFileType(*++argv))) 
        OEThrow.Error("Unknown file type \"%s\".\n",*argv);
    }
    else if (a=="-smarts")
    {
      if (--argc==0) Help("ERROR: -smarts requires value.");
      smarts=*++argv;
    }
    else if (a=="-maxmatches")
    {
      if (--argc==0) Help("ERROR: -maxmatches requires value.");
      maxmatches=atoi(*++argv);
    }
    else if (a=="-usa")
      usa=1;
    else if (a=="-asym")
      asym=1;
    else if (a=="-exph")
      exph=1;
    else if (a=="-v")
      verbose=1;
    else if (a=="-nowarn")
      nowarn=1;
    else if (a=="-help")
      Help("");
    else
      Help("ERROR: Bad option");
  }
  return 1;
}