#ifndef __JSUPPORT__JAUTOTREEWRITER__
#define __JSUPPORT__JAUTOTREEWRITER__

#include "JTools/JAutoMap.hh"
#include "JROOT/JTreeWriter.hh"
#include "JROOT/JRootFile.hh"


/**
 * \author mdejong
 */

namespace JSUPPORT {}
namespace JPP { using namespace JSUPPORT; }

namespace JSUPPORT {

  using JTOOLS::JAutoMap;
  using JROOT::JTreeCopyWriterInterface;
  using JROOT::JRootOutputFile;


  /**
   * Auxiliary class to copy input data to corresponding TTree.
   *
   * This class derives from JROOT::JRootOutputFile.
   * It re-implements the methods open and close of the underlying JLANG::JAccessible class
   * so that each TTree is properly attached to and detached from the corresponding TDirectory, respectively.
   */
  template<class JKey_t>
  class JAutoTreeWriter :
    public JAutoMap<JKey_t, JTreeCopyWriterInterface*>,
    public JRootOutputFile
  {
  public:

    typedef typename JAutoMap<JKey_t, JTreeCopyWriterInterface*>::map_type      map_type;
    typedef typename JAutoMap<JKey_t, JTreeCopyWriterInterface*>::value_type    value_type;

    typedef typename map_type::const_iterator                          const_iterator;
    typedef typename map_type::iterator                                iterator;
    typedef typename map_type::const_reverse_iterator                  const_reverse_iterator;
    typedef typename map_type::reverse_iterator                        reverse_iterator;

    using typename JAutoMap<JKey_t, JTreeCopyWriterInterface*>::insert;


    /**
     * Default constrtuctor.
     */
    JAutoTreeWriter()
    {}
    
    
    /**
     * Constructor.
     *
     * \param  type             data type
     */
    template<class T>
    JAutoTreeWriter(JType<T> type)
    {
      this->insert<T>();
    }


    /**
     * Get key.
     *
     * This method should be overloaded for the requested data types.
     *
     * \param  type             data type
     * \return                  key
     */
    template<class T>
    static JKey_t getKey(JType<T> type);


    /**
     * Insert (list of) data type(s).
     */
    template<class T>
    void insert()
    {
      insert<T>(JTOOLS::JAutomate<JElement_t>());
    }


    /**
     * Open file.
     *
     * \param  file_name      file name
     */
    virtual void open(const char* file_name) override 
    {
      JRootOutputFile::open(file_name);
      
      if (is_open()) {
        for (iterator i = this->begin(); i != this->end(); ++i) {
          i->second->SetDirectory(getFile());
	}
      }
    }


    /**
     * Close file.
     */
    virtual void close() override 
    {
      // Write objects in memory.

      if (is_open()) {
	getFile()->Write();
      }

      // Detach TTree from TDirectory to avoid deletion of TTree.

      for (iterator i = this->begin(); i != this->end(); ++i) {
	i->second->SetDirectory(0);
      }

      // Close file.
      
      if (is_open()) {
	getFile()->Close();
      }

      reset();

      // Reset TTree for next run.
      
      for (iterator i = this->begin(); i != this->end(); ++i) {
	i->second->Reset();
      }
    }

    
  protected:
    /**
     * Auxiliary class for element insertion.
     */
    struct JElement_t : 
      public value_type
    {
      /**
       * Constructor.
       *
       * \param  type             data type
       */
      template<class T>
      JElement_t(JType<T> type) :
	value_type(getKey(type), &JROOT::getTreeCopyWriter<T>())
      {}
    };
  };
}

#endif