#include "TObject.h"
#include "TError.h"
#include "TROOT.h"
#include "TPluginManager.h"
#include "TClass.h"
#include "TString.h"
#include "TSystem.h"

TString fUserClassImp = "";

TPluginHandler*	LoadPlugin(const Char_t* base, const Char_t* uri = "0");

TObject* GetInstanceOfUserClass(const Char_t* UserClass, const Char_t* UserBaseClass)
{
   //UserClass = name of user's class
   //UserBaseClass = name of base class from which user's class inherits
   
   TString fUserClass = UserClass;
   TString fUserBaseClass = UserBaseClass;
   
   //first unload any previously compiled user class shared objects
   if(fUserClassImp!="" && fUserClassImp.Contains(fUserClass)){
      TString tmp =fUserClassImp;
      tmp.ReplaceAll(".","_");
      tmp+=".so";
      Info("GetInstanceOfUserClass", "Unloading previously compiled user class shared object : %s",
            tmp.Data());
      gSystem->Unload(tmp.Data());
      gROOT->GetPluginManager()->RemoveHandler(fUserBaseClass.Data(), fUserClass.Data());
      TClass::RemoveClass(TClass::GetClass(fUserClass.Data()));
   }
   if(fUserClassImp=="") fUserClassImp.Form("%s.cpp", fUserClass.Data());
   //do we have a plugin ?
   TPluginHandler* ph = gROOT->GetPluginManager()->FindHandler(fUserBaseClass.Data(), fUserClass.Data());
   Bool_t remove_handler=kFALSE;
   if( !ph ){//no plugin defined
      //add plugin
      Info("GetInstanceOfUserClass", "added plugin handler for %s", fUserClass.Data());
      gROOT->GetPluginManager()->AddHandler(fUserBaseClass.Data(),
            fUserClass.Data(), fUserClass.Data(),
            Form("%s+", fUserClassImp.Data()), Form("%s()", fUserClass.Data()));
      ph = gROOT->GetPluginManager()->FindHandler(fUserBaseClass.Data(), fUserClass.Data());
      if( !ph ){
         Error( "GetInstanceOfUserClass", "Weird...cant add plugin");
         return 0;
      }
      remove_handler=kTRUE;
   }
   else
   {
      Info("GetInstanceOfUserClass", "found plugin handler for %s", fUserClass.Data());
   }
   
   //check compilation of class
   ph = LoadPlugin(fUserBaseClass.Data(), fUserClass.Data());
   if(!ph){
      Info("GetInstanceOfUserClass", "LoadPlugin failed for %s", fUserClass.Data());
      //remove bad handler
      if(remove_handler) gROOT->GetPluginManager()->RemoveHandler(fUserBaseClass.Data(), fUserClass.Data());
      return 0;
   }
   TObject* obj = (TObject*)ph->ExecPlugin(0);
   if(obj){
      Info("GetInstanceOfUserClass", "constructor OK for %s", fUserClass.Data());
      if(obj->InheritsFrom(fUserBaseClass.Data())) return obj;
      Info("GetInstanceOfUserClass", "%s does not inherit from %s", fUserClass.Data(), fUserBaseClass.Data());
      //remove bad handler
      if(remove_handler) gROOT->GetPluginManager()->RemoveHandler(fUserBaseClass.Data(), fUserClass.Data());
      return 0;
   }
   else
   {
      //Info("GetInstanceOfUserClass", "constructor not OK for %s", fUserClass.Data());
      //remove bad handler
      if(remove_handler) gROOT->GetPluginManager()->RemoveHandler(fUserBaseClass.Data(), fUserClass.Data());
   }
   return 0;
}

//_____________________________________________________________________________________________

TPluginHandler *LoadPlugin(const Char_t * base, const Char_t * uri)
{
   //Load plugin library in order to extend capabilities of base class "base", depending on
   //the given uri (these arguments are used to call TPluginManager::FindHandler).
   //Returns pointer to TPluginHandler.
   //Returns 0 in case of problems.

   //does plugin exist for given name ?
   TPluginHandler *ph =
       (TPluginHandler *) gROOT->GetPluginManager()->FindHandler(base,
                                                                 uri);
   if (!ph)
      return 0;

   //check plugin library/macro is available
   if (ph->CheckPlugin() != 0)
      return 0;

   //load plugin module
   if (ph->LoadPlugin() != 0)
      return 0;

   return ph;
}