/*
    * Copyright 2012-2025 CodeLibs Project and the Others.
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
   * either express or implied. See the License for the specific language
   * governing permissions and limitations under the License.
   */
  package org.codelibs.fess.app.web.admin.plugin;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.stream.Collectors;
  
  import org.apache.logging.log4j.LogManager;
  import org.apache.logging.log4j.Logger;
  import org.codelibs.core.io.CopyUtil;
  import org.codelibs.fess.annotation.Secured;
  import org.codelibs.fess.app.web.base.FessAdminAction;
  import org.codelibs.fess.helper.PluginHelper;
  import org.codelibs.fess.helper.PluginHelper.Artifact;
  import org.codelibs.fess.helper.PluginHelper.ArtifactType;
  import org.codelibs.fess.util.ComponentUtil;
  import org.codelibs.fess.util.RenderDataUtil;
  import org.lastaflute.web.Execute;
  import org.lastaflute.web.response.HtmlResponse;
  import org.lastaflute.web.ruts.process.ActionRuntime;
  import org.lastaflute.web.validation.exception.ValidationErrorException;
  
  /**
   * Admin action for Plugin management.
   * This class provides functionality for installing, deleting, and managing plugins in the Fess system.
   *
   */
  public class AdminPluginAction extends FessAdminAction {
  
      /**
       * Default constructor.
       */
      public AdminPluginAction() {
          super();
      }
  
      /**
       * Role identifier for plugin administration.
       */
      public static final String ROLE = "admin-plugin";
  
      private static final Logger logger = LogManager.getLogger(AdminPluginAction.class);
  
      private static final String UPLOAD = "upload";
  
      @Override
      protected void setupHtmlData(final ActionRuntime runtime) {
          super.setupHtmlData(runtime);
          runtime.registerData("helpLink", systemHelper.getHelpLink(fessConfig.getOnlineHelpNamePlugin()));
      }
  
      /**
       * Returns the action role for this controller.
       *
       * @return the role identifier for plugin administration
       */
      @Override
      protected String getActionRole() {
          return ROLE;
      }
  
      /**
       * Displays the plugin management index page.
       *
       * @return HTML response for the index page
       */
      @Execute
      @Secured({ ROLE, ROLE + VIEW })
      public HtmlResponse index() {
          saveToken();
          return asListHtml();
      }
  
      /**
       * Deletes the specified plugin.
       *
       * @param form the delete form containing plugin information
       * @return HTML response redirecting to the plugin list
      */
     @Execute
     @Secured({ ROLE })
     public HtmlResponse delete(final DeleteForm form) {
         validate(form, messages -> {}, () -> asHtml(path_AdminPlugin_AdminPluginJsp));
         verifyToken(() -> asHtml(path_AdminPlugin_AdminPluginJsp));
         final Artifact artifact = new Artifact(form.name, form.version, null);
         deleteArtifact(artifact);
         saveInfo(messages -> messages.addSuccessDeletePlugin(GLOBAL, artifact.getFileName()));
         return redirect(getClass());
     }
 
     /**
      * Installs a plugin from either an uploaded JAR file or from the available artifacts.
      *
      * @param form the install form containing plugin installation details
      * @return HTML response redirecting to the plugin list
      */
     @Execute
     @Secured({ ROLE })
     public HtmlResponse install(final InstallForm form) {
         validate(form, messages -> {}, () -> asHtml(path_AdminPlugin_AdminPluginInstallpluginJsp));
         verifyToken(() -> asHtml(path_AdminPlugin_AdminPluginInstallpluginJsp));
         try {
             if (UPLOAD.equals(form.id)) {
                 if (form.jarFile == null) {
                     throwValidationError(messages -> messages.addErrorsPluginFileIsNotFound(GLOBAL, form.id), this::asListHtml);
                 }
                 if (!form.jarFile.getFileName().endsWith(".jar")) {
                     throwValidationError(messages -> messages.addErrorsFileIsNotSupported(GLOBAL, form.jarFile.getFileName()),
                             this::asListHtml);
                 }
                 final String filename = form.jarFile.getFileName();
                 final File tempFile = ComponentUtil.getSystemHelper().createTempFile("tmp-adminplugin-", ".jar");
                 try (final InputStream is = form.jarFile.getInputStream(); final OutputStream os = new FileOutputStream(tempFile)) {
                     CopyUtil.copy(is, os);
                 } catch (final Exception e) {
                     if (tempFile.exists() && !tempFile.delete()) {
                         logger.warn("Failed to delete {}.", tempFile.getAbsolutePath());
                     }
                     logger.debug("Failed to copy {}", filename, e);
                     throwValidationError(messages -> messages.addErrorsFailedToInstallPlugin(GLOBAL, filename), this::asListHtml);
                 }
                 new Thread(() -> {
                     try {
                         final PluginHelper pluginHelper = ComponentUtil.getPluginHelper();
                         final Artifact artifact =
                                 pluginHelper.getArtifactFromFileName(ArtifactType.UNKNOWN, filename, tempFile.getAbsolutePath());
                         pluginHelper.installArtifact(artifact);
                     } catch (final Exception e) {
                         logger.warn("Failed to install {}", filename, e);
                     } finally {
                         if (tempFile.exists() && !tempFile.delete()) {
                             logger.warn("Failed to delete {}.", tempFile.getAbsolutePath());
                         }
                     }
                 }).start();
                 saveInfo(messages -> messages.addSuccessInstallPlugin(GLOBAL, form.jarFile.getFileName()));
             } else {
                 final Artifact artifact = getArtifactFromInstallForm(form);
                 if (artifact == null) {
                     throwValidationError(messages -> messages.addErrorsCrudCouldNotFindCrudTable(GLOBAL, form.id), this::asListHtml);
                 }
                 installArtifact(artifact);
                 saveInfo(messages -> messages.addSuccessInstallPlugin(GLOBAL, artifact.getFileName()));
             }
         } catch (final ValidationErrorException e) {
             throw e;
         } catch (final Exception e) {
             throwValidationError(messages -> messages.addErrorsFailedToInstallPlugin(GLOBAL, form.id), this::asListHtml);
         }
         return redirect(getClass());
     }
 
     /**
      * Displays the plugin installation page with available plugins.
      *
      * @return HTML response for the plugin installation page
      */
     @Execute
     @Secured({ ROLE })
     public HtmlResponse installplugin() {
         saveToken();
         return asHtml(path_AdminPlugin_AdminPluginInstallpluginJsp).renderWith(data -> {
             final List<Map<String, String>> result = new ArrayList<>();
             final Map<String, String> map = new HashMap<>();
             map.put("id", UPLOAD);
             map.put("name", "");
             map.put("version", "");
             result.add(map);
             try {
                 result.addAll(getAllAvailableArtifacts());
             } catch (final Exception e) {
                 saveError(messages -> messages.addErrorsFailedToFindPlugins(GLOBAL));
                 logger.warn("Failed to access a plugin repository.", e);
             }
             RenderDataUtil.register(data, "availableArtifactItems", result);
         }).useForm(InstallForm.class, op -> op.setup(form -> {}));
     }
 
     private HtmlResponse asListHtml() {
         return asHtml(path_AdminPlugin_AdminPluginJsp)
                 .renderWith(data -> data.register("installedArtifactItems", getAllInstalledArtifacts()))
                 .useForm(DeleteForm.class);
     }
 
     /**
      * Retrieves all available artifacts from all plugin types.
      *
      * @return list of maps containing artifact information
      */
     public static List<Map<String, String>> getAllAvailableArtifacts() {
         final PluginHelper pluginHelper = ComponentUtil.getPluginHelper();
         final List<Map<String, String>> result = new ArrayList<>();
         for (final PluginHelper.ArtifactType artifactType : PluginHelper.ArtifactType.values()) {
             result.addAll(Arrays.stream(pluginHelper.getAvailableArtifacts(artifactType))
                     .map(AdminPluginAction::beanToMap)
                     .collect(Collectors.toList()));
         }
         return result;
     }
 
     /**
      * Retrieves all installed artifacts from all plugin types.
      *
      * @return list of maps containing installed artifact information
      */
     public static List<Map<String, String>> getAllInstalledArtifacts() {
         final PluginHelper pluginHelper = ComponentUtil.getPluginHelper();
         final List<Map<String, String>> result = new ArrayList<>();
         for (final PluginHelper.ArtifactType artifactType : PluginHelper.ArtifactType.values()) {
             result.addAll(Arrays.stream(pluginHelper.getInstalledArtifacts(artifactType))
                     .map(AdminPluginAction::beanToMap)
                     .collect(Collectors.toList()));
         }
         return result;
     }
 
     /**
      * Converts an Artifact object to a Map representation.
      *
      * @param artifact the artifact to convert
      * @return map containing artifact properties
      */
     public static Map<String, String> beanToMap(final Artifact artifact) {
         final Map<String, String> item = new HashMap<>();
         item.put("type", artifact.getType().getId());
         item.put("id", artifact.getName() + ":" + artifact.getVersion());
         item.put("name", artifact.getName());
         item.put("version", artifact.getVersion());
         item.put("url", artifact.getUrl());
         return item;
     }
 
     private Artifact getArtifactFromInstallForm(final InstallForm form) {
         final String[] values = form.id.split(":");
         return ComponentUtil.getPluginHelper().getArtifact(values[0], values[1]);
     }
 
     /**
      * Installs the specified artifact in a background thread.
      * Also removes any previously installed versions of the same plugin.
      *
      * @param artifact the artifact to install
      */
     public static void installArtifact(final Artifact artifact) {
         new Thread(() -> {
             final PluginHelper pluginHelper = ComponentUtil.getPluginHelper();
             final Artifact[] artifacts = pluginHelper.getInstalledArtifacts(artifact.getType());
             try {
                 pluginHelper.installArtifact(artifact);
             } catch (final Exception e) {
                 logger.warn("Failed to install {}", artifact.getFileName(), e);
             }
             for (final Artifact a : artifacts) {
                 if (a.getName().equals(artifact.getName()) && !a.getVersion().equals(artifact.getVersion())) {
                     try {
                         pluginHelper.deleteInstalledArtifact(a);
                     } catch (final Exception e) {
                         logger.warn("Failed to delete {}", a.getFileName(), e);
                     }
                 }
             }
         }).start();
     }
 
     /**
      * Deletes the specified artifact in a background thread.
      *
      * @param artifact the artifact to delete
      */
     public static void deleteArtifact(final Artifact artifact) {
         new Thread(() -> {
             try {
                 ComponentUtil.getPluginHelper().deleteInstalledArtifact(artifact);
             } catch (final Exception e) {
                 logger.warn("Failed to delete {}", artifact.getFileName(), e);
             }
         }).start();
     }
 }