/* ----------------------------------------------------------------------
   LAMMPS - Large-scale Atomic/Molecular Massively Parallel Simulator
   https://lammps.sandia.gov/, Sandia National Laboratories
   Steve Plimpton, sjplimp@sandia.gov

   Copyright (2003) Sandia Corporation.  Under the terms of Contract
   DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government retains
   certain rights in this software.  This software is distributed under
   the GNU General Public License.

   See the README file in the top-level LAMMPS directory.
------------------------------------------------------------------------- */

#include "plugin.h"

#include "comm.h"
#include "domain.h"
#include "error.h"
#include "input.h"
#include "force.h"
#include "lammps.h"
#include "modify.h"

#include <map>
#include <list>

#ifdef _WIN32
#include <windows.h>
#else
#include <dlfcn.h>
#endif

namespace LAMMPS_NS
{
  // list of plugin information data for loaded styles
  static std::list<lammpsplugin_t> pluginlist;

  // map for counting references to dso handles
  static std::map<void *, int> dso_refcounter;


/* ---------------------------------------------------------------------- */

  Plugin::Plugin(LAMMPS *lmp) : Command(lmp) {}

/* ---------------------------------------------------------------------- */

  void Plugin::command(int narg, char **arg)
  {
    if (narg < 1) error->all(FLERR,"Illegal plugin command");

#if defined(LMP_PLUGIN)
    std::string cmd = arg[0];
    if (cmd == "load") {
      if (narg < 2) error->all(FLERR,"Illegal plugin load command");
      for (int i=1; i < narg; ++i)
        plugin_load(arg[i],lmp);

    } else if (cmd == "unload") {
      if (narg != 3) error->all(FLERR,"Illegal plugin unload command");
      plugin_unload(arg[1],arg[2],lmp);

    } else if (cmd == "clear") {
      plugin_clear(lmp);

    } else if (cmd == "list") {
      if (comm->me == 0) {
        int num = plugin_get_num_plugins();
        utils::logmesg(lmp,"Currently loaded plugins\n");
        for (int i=0; i < num; ++i) {
          auto entry = plugin_get_info(i);
          utils::logmesg(lmp,"{:4}: {} style plugin {}\n",
                         i+1,entry->style,entry->name);
        }
      }
    } else error->all(FLERR,"Illegal plugin command");
#else
    if (comm->me == 0)
      error->warning(FLERR,"Ignoring plugin command. LAMMPS must be built as "
                     "a shared library for it to work.");
#endif
  }

  // load DSO and call included registration function
  void plugin_load(const char *file, LAMMPS *lmp)
  {
#if defined(LMP_PLUGIN)
    int me = lmp->comm->me;
#if defined(WIN32)
    lmp->error->all(FLERR,"Loading of plugins on Windows is not supported\n");
#else

    // open DSO file from given path; load symbols globally

    dlerror();
    void *dso = dlopen(file,RTLD_NOW|RTLD_GLOBAL);
    if (dso == nullptr) {
      if (me == 0)
        utils::logmesg(lmp,"Open of file {} failed: {}\n",file,dlerror());
      return;
    }

    // look up lammpsplugin_init() function in DSO
    // function must have C bindings so there is no name mangling

    dlerror();
    void *initfunc = dlsym(dso,"lammpsplugin_init");
    if (initfunc == nullptr) {
      dlclose(dso);

      if (me == 0)
        utils::logmesg(lmp,"Plugin symbol lookup failure in file {}: {}\n",
                       file,dlerror());
      return;
    }

    // call initializer function loaded from DSO and pass a pointer
    // to the LAMMPS instance, the DSO handle (for reference counting)
    // and plugin registration function pointer

    (*(lammpsplugin_initfunc)(initfunc))((void *)lmp, dso,
                                         (void *)&plugin_register);
#endif
#endif
  }

  /* --------------------------------------------------------------------
     register a new style from a plugin with LAMMPS
     this is the callback function that is called from within
     the plugin initializer function. all plugin information
     is taken from the lammpsplugin_t struct.
     -------------------------------------------------------------------- */

  void plugin_register(lammpsplugin_t *plugin, void *ptr)
  {
#if defined(LMP_PLUGIN)
    LAMMPS *lmp = (LAMMPS *)ptr;
    int me = lmp->comm->me;

    if (plugin == nullptr) return;

    // ignore load request if same plugin already loaded
    int idx = plugin_find(plugin->style,plugin->name);
    if (idx >= 0) {
      if (me == 0)
        utils::logmesg(lmp,"Ignoring load of {} style {}: must "
                       "unload existing {} plugin first\n",
                       plugin->style,plugin->name,plugin->name);
      return;
    }

    if (me == 0) {
      utils::logmesg(lmp,"Loading plugin: {} by {}\n",
                     plugin->info,plugin->author);
      // print version info only if the versions of host and plugin don't match
      if ((plugin->version) && (strcmp(plugin->version,lmp->version) != 0))
        utils::logmesg(lmp,"  compiled for LAMMPS version {}, loaded into "
                       "LAMMPS version {}\n",plugin->version,lmp->version);
    }

    pluginlist.push_back(*plugin);

    if (dso_refcounter.find(plugin->handle) != dso_refcounter.end()) {
      ++ dso_refcounter[plugin->handle];
    } else {
      dso_refcounter[plugin->handle] = 1;
    }

    std::string pstyle = plugin->style;
    if (pstyle == "pair") {
      auto pair_map = lmp->force->pair_map;
      if (pair_map->find(plugin->name) != pair_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in pair "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*pair_map)[plugin->name] = (Force::PairCreator)plugin->creator.v1;

    } else if (pstyle == "bond") {
      auto bond_map = lmp->force->bond_map;
      if (bond_map->find(plugin->name) != bond_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in bond "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*bond_map)[plugin->name] = (Force::BondCreator)plugin->creator.v1;

    } else if (pstyle == "angle") {
      auto angle_map = lmp->force->angle_map;
      if (angle_map->find(plugin->name) != angle_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in angle "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*angle_map)[plugin->name] = (Force::AngleCreator)plugin->creator.v1;

    } else if (pstyle == "dihedral") {
      auto dihedral_map = lmp->force->dihedral_map;
      if (dihedral_map->find(plugin->name) != dihedral_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in dihedral "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*dihedral_map)[plugin->name] = (Force::DihedralCreator)plugin->creator.v1;

    } else if (pstyle == "improper") {
      auto improper_map = lmp->force->improper_map;
      if (improper_map->find(plugin->name) != improper_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in improper "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*improper_map)[plugin->name] = (Force::ImproperCreator)plugin->creator.v1;

    } else if (pstyle == "compute") {
      auto compute_map = lmp->modify->compute_map;
      if (compute_map->find(plugin->name) != compute_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in compute "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*compute_map)[plugin->name] = (Modify::ComputeCreator)plugin->creator.v2;

    } else if (pstyle == "fix") {
      auto fix_map = lmp->modify->fix_map;
      if (fix_map->find(plugin->name) != fix_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in fix "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*fix_map)[plugin->name] = (Modify::FixCreator)plugin->creator.v2;

    } else if (pstyle == "region") {
      auto region_map = lmp->domain->region_map;
      if (region_map->find(plugin->name) != region_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in region "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*region_map)[plugin->name] = (Domain::RegionCreator)plugin->creator.v2;

    } else if (pstyle == "command") {
      auto command_map = lmp->input->command_map;
      if (command_map->find(plugin->name) != command_map->end()) {
        if (lmp->comm->me == 0)
          lmp->error->warning(FLERR,fmt::format("Overriding built-in command "
                                                "style {} from plugin",
                                                plugin->name));
      }
      (*command_map)[plugin->name] = (Input::CommandCreator)plugin->creator.v1;

    } else {
      utils::logmesg(lmp,"Loading plugins for {} styles not "
                     "yet implemented\n",pstyle);
      pluginlist.pop_back();
    }
#endif
  }

  /* --------------------------------------------------------------------
     remove plugin from given style table and plugin list
     optionally close the DSO handle if it is the last plugin from that DSO
     must also delete style instances if style is currently active
     -------------------------------------------------------------------- */

  void plugin_unload(const char *style, const char *name, LAMMPS *lmp)
  {
#if defined(LMP_PLUGIN)
    int me = lmp->comm->me;

    // ignore unload request from unsupported style categories
    if ((strcmp(style,"pair") != 0) && (strcmp(style,"bond") != 0)
        && (strcmp(style,"angle") != 0) && (strcmp(style,"dihedral") != 0)
        && (strcmp(style,"improper") != 0) && (strcmp(style,"compute") != 0)
        && (strcmp(style,"fix") != 0) && (strcmp(style,"region") != 0)
        && (strcmp(style,"command") != 0)) {
      if (me == 0)
        utils::logmesg(lmp,"Ignoring unload: {} is not a "
                       "supported plugin style\n",style);
      return;
    }

    // ignore unload request if not loaded from a plugin
    int idx = plugin_find(style,name);
    if (idx < 0) {
      if (me == 0)
        utils::logmesg(lmp,"Ignoring unload of {} style {}: not "
                       "loaded from a plugin\n",style,name);
      return;
    }

    // make copy of DSO handle for later use
    void *handle = plugin_get_info(idx)->handle;

    // remove selected plugin from list of plugins

    if (me == 0)
      utils::logmesg(lmp,"Unloading {} style {}\n",style,name);
    plugin_erase(style,name);

    // remove style of given name from corresponding map
    // must delete style instance if currently active so
    // we can close the DSO handle if the last reference is gone.

    std::string pstyle = style;
    if (pstyle == "pair") {

      auto found = lmp->force->pair_map->find(name);
      if (found != lmp->force->pair_map->end())
        lmp->force->pair_map->erase(found);

      // must delete pair style instance if in use

      if (lmp->force->pair_style) {
        if (utils::strmatch(lmp->force->pair_style,"^hybrid")) {
          if (lmp->force->pair_match(name,1,1) != nullptr)
            lmp->force->create_pair("none",0);
        } else {
          if (strcmp(lmp->force->pair_style,name) == 0)
            lmp->force->create_pair("none",0);
        }
      }

    } else if (pstyle == "bond") {

      auto found = lmp->force->bond_map->find(name);
      if (found != lmp->force->bond_map->end())
        lmp->force->bond_map->erase(found);

      // must delete bond style instance if in use

      if ((lmp->force->bond_style != nullptr)
          && (lmp->force->bond_match(name) != nullptr))
        lmp->force->create_bond("none",0);

    } else if (pstyle == "angle") {

      auto found = lmp->force->angle_map->find(name);
      if (found != lmp->force->angle_map->end())
        lmp->force->angle_map->erase(found);

      // must delete angle style instance if in use

      if ((lmp->force->angle_style != nullptr)
          && (lmp->force->angle_match(name) != nullptr))
        lmp->force->create_angle("none",0);

    } else if (pstyle == "dihedral") {

      auto found = lmp->force->dihedral_map->find(name);
      if (found != lmp->force->dihedral_map->end())
        lmp->force->dihedral_map->erase(found);

      // must delete dihedral style instance if in use

      if ((lmp->force->dihedral_style)
          && (lmp->force->dihedral_match(name) != nullptr))
        lmp->force->create_dihedral("none",0);

    } else if (pstyle == "improper") {

      auto found = lmp->force->improper_map->find(name);
      if (found != lmp->force->improper_map->end())
        lmp->force->improper_map->erase(found);

      // must delete improper style instance if in use

      if ((lmp->force->improper_style != nullptr)
          && (lmp->force->improper_match(name) != nullptr))
        lmp->force->create_improper("none",0);

    } else if (pstyle == "compute") {

      auto compute_map = lmp->modify->compute_map;
      auto found = compute_map->find(name);
      if (found != compute_map->end()) compute_map->erase(name);

      for (int icompute = lmp->modify->find_compute_by_style(name);
           icompute >= 0; icompute = lmp->modify->find_compute_by_style(name))
        lmp->modify->delete_compute(icompute);

    } else if (pstyle == "fix") {

      auto fix_map = lmp->modify->fix_map;
      auto found = fix_map->find(name);
      if (found != fix_map->end()) fix_map->erase(name);

      for (int ifix = lmp->modify->find_fix_by_style(name);
           ifix >= 0; ifix = lmp->modify->find_fix_by_style(name))
        lmp->modify->delete_fix(ifix);

    } else if (pstyle == "region") {

      auto region_map = lmp->domain->region_map;
      auto found = region_map->find(name);
      if (found != region_map->end()) region_map->erase(name);

      for (int iregion = lmp->domain->find_region_by_style(name);
           iregion >= 0; iregion = lmp->domain->find_region_by_style(name))
        lmp->domain->delete_region(iregion);

    } else if (pstyle == "command") {

      auto command_map = lmp->input->command_map;
      auto found = command_map->find(name);
      if (found != command_map->end()) command_map->erase(name);
    }

    // if reference count is down to zero, close DSO handle.

    -- dso_refcounter[handle];
    if (dso_refcounter[handle] == 0) {
#ifndef WIN32
      dlclose(handle);
#endif
    }
#endif
  }

  /* --------------------------------------------------------------------
     unload all loaded plugins
     -------------------------------------------------------------------- */

  void plugin_clear(LAMMPS *lmp)
  {
    while (pluginlist.size() > 0) {
      auto p = pluginlist.begin();
      plugin_unload(p->style,p->name,lmp);
    }
  }

  /* --------------------------------------------------------------------
     remove plugin of given name and style from internal lists
     -------------------------------------------------------------------- */

  void plugin_erase(const char *style, const char *name)
  {
    for (auto p=pluginlist.begin(); p != pluginlist.end(); ++p) {
      if ((strcmp(style,p->style) == 0)
          && (strcmp(name,p->name) == 0)) {
        pluginlist.erase(p);
        return;
      }
    }
  }

  /* --------------------------------------------------------------------
     number of styles loaded from plugin files
     -------------------------------------------------------------------- */

  int plugin_get_num_plugins()
  {
    return pluginlist.size();
  }

  /* --------------------------------------------------------------------
     return position index in list of given plugin of given style
     -------------------------------------------------------------------- */

  int plugin_find(const char *style, const char *name)
  {
    int i=0;
    for (auto entry : pluginlist) {
      if ((strcmp(style,entry.style) == 0)
          && (strcmp(name,entry.name) == 0))
        return i;
      ++i;
    }
    return -1;
  }

  /* --------------------------------------------------------------------
     get pointer to plugin initializer struct at position idx
     -------------------------------------------------------------------- */

  const lammpsplugin_t *plugin_get_info(int idx)
  {
    int i=0;
    for (auto p=pluginlist.begin(); p != pluginlist.end(); ++p) {
      if (i == idx) return &(*p);
      ++i;
    }
    return nullptr;
  }
}