#include <openbabel/babelconfig.h>
#include <openbabel/op.h>
#include <openbabel/obconversion.h>
#include <vector>
#include <algorithm>

namespace OpenBabel
{
/**
DeferredFormat class is intended to assist writing ops that influence the
conversion of multiple molecules with the OBConversion Convert interface.
See, for instance, OpSort. Although it is a format, it does not registered
itself, an object is not constructed in ReadChemObject() or deleted in
WriteChemObject(). It is used in a different way from normal formats. An 
op makes an instance of DeferredFormat, probably when it is first called
in its Do() function.
\code
  if(pConv && pConv->IsFirstInput())
    new DeferredFormat(pConv, this); //it will delete itself
\endcode
Output objects (probably molecules) will then all be diverted to the
DeferredFormat instance and pointers to them stored there. After the last
object, it calls the op's ProcessVec(std::vector<OBBase*>& vec) function.
The objects can be manipulated or deleted (call delete with their pointer).
When the function returns, the remaining molecules in the vector will be
output to the normal output format. No conversion options are applied at
this stage, since they already have been earlier.

Constructing with a third boolean parameter set true allows an alternative mode
of operation. Before storing the pointer to an object, DeferredFormat calls
the op's Do() function and stores the object pointer only if this returns true.
This has the effect of allowing the op to act after all the other options,
rather than before most of them. See OpLargest for an example.
**/
class DeferredFormat : public OBFormat
{
public:
  DeferredFormat(OBConversion* pConv, OBOp* pOp=nullptr, bool CallDo=false)
  {
    _pRealOutFormat = pConv->GetOutFormat();
    pConv->SetOutFormat(this);
    _pOp = pOp;
    _callDo = CallDo;
  }
  const char* Description() override { return "Read and write an OBBase* array"; }

  bool ReadChemObject(OBConversion* pConv) override
  {
    if(_obvec.empty())
    {
      delete this;//self destruction; was made in new in an OBOp
      return false;
    }
    //returned in reverse order, because its easier with a vector
    pConv->AddChemObject(_obvec.back());
    _obvec.pop_back();
    return true;
  }

  bool WriteChemObject(OBConversion* pConv) override
  {
    OBBase* pOb = pConv->GetChemObject();
    if(!_callDo || _pOp->Do(pOb, "", pConv->GetOptions(OBConversion::GENOPTIONS), pConv))  
      _obvec.push_back(pOb); // Store the object pointer.

    if(pConv->IsLast())
    {
      //At the end, sort, or whatever, the vector
      if(_pOp)
      {
        //clear the options if return is true - they have already been applied
        if(_pOp->ProcessVec(_obvec))
          pConv->SetOptions("",OBConversion::GENOPTIONS);

        //Now output the processed vector, unless it is empty
        if(!_obvec.empty())
        {
          std::reverse(_obvec.begin(),_obvec.end()); //because DeferredFormat outputs in reverse order
          pConv->SetInAndOutFormats(this, _pRealOutFormat);

          std::ifstream ifs; // get rid of gcc warning
          pConv->SetInStream(&ifs);//Not used, but Convert checks it is ok
          pConv->GetInStream()->clear();

          pConv->SetOutputIndex(0);
          pConv->Convert();
        }
      }
    }
    return true;
  }
private:
  OBFormat* _pRealOutFormat;
  std::vector<OBBase*> _obvec;
  public:
  OBOp* _pOp;
  bool _callDo;
};

} //namespace

