/*
 * HEIF codec.
 * Copyright (c) 2022 Dirk Farin <dirk.farin@gmail.com>
 *
 * This file is part of libheif.
 *
 * libheif is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * libheif is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with libheif.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "init.h"
#include "libheif/heif.h"
#include "error.h"
#include "plugin_registry.h"
#include "common_utils.h"
#include "color-conversion/colorconversion.h"

#if ENABLE_MULTITHREADING_SUPPORT

#include <mutex>

#endif

#if defined(_WIN32)
#include "plugins_windows.h"
#else

#include "plugins_unix.h"

#endif

#define STRINGIFY2(x) #x
#define STRINGIFY(x) STRINGIFY2(x)

void heif_unload_all_plugins();

#if ENABLE_PLUGIN_LOADING

void heif_unregister_encoder_plugin(const heif_encoder_plugin* plugin);

std::vector<std::string> get_plugin_paths()
{
  std::vector<std::string> plugin_paths;

#if defined(_WIN32)
  plugin_paths = get_plugin_directories_from_environment_variable_windows();
#else
  plugin_paths = get_plugin_directories_from_environment_variable_unix();
#endif

  if (plugin_paths.empty()) {
    plugin_paths.push_back(LIBHEIF_PLUGIN_DIRECTORY);
  }

  return plugin_paths;
}

std::vector<std::string> list_all_potential_plugins_in_directory(const char* directory)
{
#if defined(_WIN32)
  return list_all_potential_plugins_in_directory_windows(directory);
#else
  return list_all_potential_plugins_in_directory_unix(directory);
#endif
}

#else
std::vector<std::string> get_plugin_paths()
{
  return {};
}
#endif


static int heif_library_initialization_count = 0;
static bool default_plugins_registered = true; // because they are implicitly registered at startup


#if ENABLE_MULTITHREADING_SUPPORT

static std::recursive_mutex& heif_init_mutex()
{
  static std::recursive_mutex init_mutex;
  return init_mutex;
}

#endif


void load_plugins_if_not_initialized_yet()
{
  if (heif_library_initialization_count == 0) {
    heif_init(nullptr);
  }
}


heif_error heif_init(heif_init_params*)
{
#if ENABLE_MULTITHREADING_SUPPORT
  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
#endif

  if (heif_library_initialization_count == 0) {

    ColorConversionPipeline::init_ops();

    // --- initialize builtin plugins

    if (!default_plugins_registered) {
      register_default_plugins();
    }

#if ENABLE_PLUGIN_LOADING
    struct heif_error err{};
    std::vector<std::string> plugin_paths = get_plugin_paths();

    for (const auto& dir : plugin_paths) {
      err = heif_load_plugins(dir.c_str(), nullptr, nullptr, 0);
      if (err.code != 0) {
        return err;
      }
    }
#endif
  }

  // Note: it is important that we increase the counter AFTER initialization such that
  // 'load_plugins_if_not_initialized_yet()' can check this without having to lock the mutex.
  heif_library_initialization_count++;

  return {heif_error_Ok, heif_suberror_Unspecified, Error::kSuccess};
}


void heif_deinit()
{
#if ENABLE_MULTITHREADING_SUPPORT
  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
#endif

  if (heif_library_initialization_count == 0) {
    // This case should never happen (heif_deinit() is called more often than heif_init()).
    return;
  }

  if (heif_library_initialization_count == 1) {
    heif_unregister_decoder_plugins();
    heif_unregister_encoder_plugins();
    default_plugins_registered = false;

    heif_unload_all_plugins();

    ColorConversionPipeline::release_ops();
  }

  // Note: contrary to heif_init() I think it does not matter whether we decrease the counter before or after deinitialization.
  // If the client application calls heif_deinit() in parallel to some other libheif function, it is really broken.
  heif_library_initialization_count--;
}


// This could be inside ENABLE_PLUGIN_LOADING, but the "include-what-you-use" checker cannot process this.
#include <vector>
#include <string>
#include <cstring>

#if ENABLE_PLUGIN_LOADING

#if defined(_WIN32)
typedef PluginLibrary_Windows PluginLibrary_SysDep;
#else
typedef PluginLibrary_Unix PluginLibrary_SysDep;
#endif


struct loaded_plugin
{
  PluginLibrary_SysDep plugin_library_handle;
  struct heif_plugin_info* info = nullptr;
  int openCnt = 0;
};

static std::vector<loaded_plugin> sLoadedPlugins;

MAYBE_UNUSED heif_error error_dlopen{heif_error_Plugin_loading_error, heif_suberror_Plugin_loading_error, "Cannot open plugin (dlopen)."};
MAYBE_UNUSED heif_error error_plugin_not_loaded{heif_error_Plugin_loading_error, heif_suberror_Plugin_is_not_loaded, "Trying to remove a plugin that is not loaded."};
MAYBE_UNUSED heif_error error_cannot_read_plugin_directory{heif_error_Plugin_loading_error, heif_suberror_Cannot_read_plugin_directory, "Cannot read plugin directory."};

MAYBE_UNUSED static void unregister_plugin(const heif_plugin_info* info)
{
  switch (info->type) {
    case heif_plugin_type_encoder: {
      auto* encoder_plugin = static_cast<const heif_encoder_plugin*>(info->plugin);
      heif_unregister_encoder_plugin(encoder_plugin);
      break;
    }
    case heif_plugin_type_decoder: {
      // TODO
    }
  }
}


struct heif_error heif_load_plugin(const char* filename, struct heif_plugin_info const** out_plugin)
{
#if ENABLE_MULTITHREADING_SUPPORT
  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
#endif

  PluginLibrary_SysDep plugin;
  auto err = plugin.load_from_file(filename);
  if (err.code) {
    return err;
  }

  heif_plugin_info* plugin_info = plugin.get_plugin_info();

  // --- check whether the plugin is already loaded
  // If yes, return pointer to existing plugin.

  for (auto& p : sLoadedPlugins) {
    if (p.plugin_library_handle == plugin) {
      if (out_plugin) {
        *out_plugin = p.info;
        p.openCnt++;
        return heif_error_ok;
      }
    }
  }

  loaded_plugin loadedPlugin;
  loadedPlugin.plugin_library_handle = plugin;
  loadedPlugin.openCnt = 1;
  loadedPlugin.info = plugin_info;
  sLoadedPlugins.push_back(loadedPlugin);

  *out_plugin = plugin_info;

  switch (loadedPlugin.info->type) {
    case heif_plugin_type_encoder: {
      auto* encoder_plugin = static_cast<const heif_encoder_plugin*>(plugin_info->plugin);
      if (encoder_plugin->plugin_api_version < heif_encoder_plugin_minimum_version) {
        return {heif_error_Plugin_loading_error,
                heif_suberror_Unsupported_plugin_version,
                "Encoder plugin needs to be at least version " STRINGIFY(heif_encoder_plugin_latest_version)
        };
      }

      if (encoder_plugin->plugin_api_version >= 4 &&
          encoder_plugin->minimum_required_libheif_version > heif_get_version_number()) {
        return {
          heif_error_Plugin_loading_error,
          heif_suberror_Unsupported_plugin_version,
          "Encoder plugin requires at least libheif version " LIBHEIF_VERSION
        };
      }

      struct heif_error err = heif_register_encoder_plugin(encoder_plugin);
      if (err.code) {
        return err;
      }
      break;
    }

    case heif_plugin_type_decoder: {
      auto* decoder_plugin = static_cast<const heif_decoder_plugin*>(plugin_info->plugin);
      if (decoder_plugin->plugin_api_version < heif_decoder_plugin_minimum_version) {
        return {heif_error_Plugin_loading_error,
                heif_suberror_Unsupported_plugin_version,
                "Decoder plugin needs to be at least version " STRINGIFY(heif_decoder_plugin_latest_version)
        };
      }

      if (decoder_plugin->plugin_api_version >= 4 &&
          decoder_plugin->minimum_required_libheif_version > heif_get_version_number()) {
        return {
          heif_error_Plugin_loading_error,
          heif_suberror_Unsupported_plugin_version,
          "Decoder plugin requires at least libheif version " LIBHEIF_VERSION
        };
      }

      struct heif_error err = heif_register_decoder_plugin(decoder_plugin);
      if (err.code) {
        return err;
      }
      break;
    }
  }

  return heif_error_ok;
}

struct heif_error heif_unload_plugin(const struct heif_plugin_info* plugin)
{
#if ENABLE_MULTITHREADING_SUPPORT
  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
#endif

  for (size_t i = 0; i < sLoadedPlugins.size(); i++) {
    auto& p = sLoadedPlugins[i];

    if (p.info == plugin) {
      p.plugin_library_handle.release();
      p.openCnt--;

      if (p.openCnt == 0) {
        unregister_plugin(plugin);

        sLoadedPlugins[i] = sLoadedPlugins.back();
        sLoadedPlugins.pop_back();
      }

      return heif_error_ok;
    }
  }

  return error_plugin_not_loaded;
}

void heif_unload_all_plugins()
{
#if ENABLE_MULTITHREADING_SUPPORT
  std::lock_guard<std::recursive_mutex> lock(heif_init_mutex());
#endif

  for (auto& p : sLoadedPlugins) {
    unregister_plugin(p.info);

    for (int i = 0; i < p.openCnt; i++) {
      p.plugin_library_handle.release();
    }
  }

  sLoadedPlugins.clear();
}


struct heif_error heif_load_plugins(const char* directory,
                                    const struct heif_plugin_info** out_plugins,
                                    int* out_nPluginsLoaded,
                                    int output_array_size)
{
  auto libraryFiles = list_all_potential_plugins_in_directory(directory);

  int nPlugins = 0;

  // Loading the plugins may return several errors, but we can only return one of them,
  // which is remembered here.
  heif_error err_result = heif_error_ok;

  for (const auto& filename : libraryFiles) {
    const struct heif_plugin_info* info = nullptr;
    auto err = heif_load_plugin(filename.c_str(), &info);
    if (err.code == 0) {
      if (out_plugins) {
        if (nPlugins == output_array_size) {
          break;
        }

        out_plugins[nPlugins] = info;
      }

      nPlugins++;
    }
    else {
      // remember error
      err_result = err;
    }
  }

  if (nPlugins < output_array_size && out_plugins) {
    out_plugins[nPlugins] = nullptr;
  }

  if (out_nPluginsLoaded) {
    *out_nPluginsLoaded = nPlugins;
  }

  return err_result;
}

#else
static heif_error heif_error_plugins_unsupported{heif_error_Unsupported_feature, heif_suberror_Unspecified, "Plugins are not supported"};

struct heif_error heif_load_plugin(const char* filename, struct heif_plugin_info const** out_plugin)
{
  return heif_error_plugins_unsupported;
}


struct heif_error heif_unload_plugin(const struct heif_plugin_info* plugin)
{
  return heif_error_plugins_unsupported;
}


void heif_unload_all_plugins() {}

struct heif_error heif_load_plugins(const char* directory,
                                    const struct heif_plugin_info** out_plugins,
                                    int* out_nPluginsLoaded,
                                    int output_array_size)
{
  if (out_nPluginsLoaded) {
    *out_nPluginsLoaded = 0;
  }

  return heif_error_plugins_unsupported;
}

#endif


const char* const* heif_get_plugin_directories()
{
  auto plugin_paths = get_plugin_paths();
  size_t n = plugin_paths.size();

  auto out_paths = new char* [n + 1];
  for (size_t i = 0; i < n; i++) {
    out_paths[i] = new char[plugin_paths[i].size() + 1];
    strcpy(out_paths[i], plugin_paths[i].c_str());
  }

  out_paths[n] = nullptr;

  return out_paths;
}


void heif_free_plugin_directories(const char* const* paths)
{
  for (int i = 0; paths[i]; i++) {
    delete[] paths[i];
  }

  delete[] paths;
}