/**
   * Adds to an specific given bundle a given asset. <br>
   * If the given bundle does not exist a new onw will be created with that name
   *
   * @param request HttpRequest
   * @param response HttpResponse
   */
  public void addToBundle(HttpServletRequest request, HttpServletResponse response)
      throws IOException {

    PublisherAPI publisherAPI = PublisherAPI.getInstance();
    String _assetId = request.getParameter("assetIdentifier");
    String _contentFilterDate = request.getParameter("remoteFilterDate");
    String bundleName = request.getParameter("bundleName");
    String bundleId = request.getParameter("bundleSelect");

    try {
      Bundle bundle;

      if (bundleId == null || bundleName.equals(bundleId)) {
        // if the user has a unsent bundle with that name just add to it
        bundle = null;
        for (Bundle b :
            APILocator.getBundleAPI()
                .getUnsendBundlesByName(getUser().getUserId(), bundleName, 1000, 0)) {
          if (b.getName().equalsIgnoreCase(bundleName)) {
            bundle = b;
          }
        }

        if (bundle == null) {
          bundle = new Bundle(bundleName, null, null, getUser().getUserId());
          APILocator.getBundleAPI().saveBundle(bundle);
        }
      } else {
        bundle = APILocator.getBundleAPI().getBundleById(bundleId);
      }

      // Put the selected bundle in session in order to have last one selected
      request.getSession().setAttribute(WebKeys.SELECTED_BUNDLE, bundle);

      List<String> ids;
      if (_assetId.startsWith("query_")) { // Support for lucene queries

        String luceneQuery = _assetId.replace("query_", "");
        List<String> queries = new ArrayList<String>();
        queries.add(luceneQuery);
        ids = PublisherUtil.getContentIds(queries);

      } else {

        String[] _assetsIds =
            _assetId.split(","); // Support for multiple ids in the assetIdentifier parameter
        List<String> assetsIds = Arrays.asList(_assetsIds);

        ids = getIdsToPush(assetsIds, _contentFilterDate, new SimpleDateFormat("yyyy-MM-dd-H-m"));
      }

      Map<String, Object> responseMap =
          publisherAPI.saveBundleAssets(ids, bundle.getId(), getUser());

      // If we have errors lets return them in order to feedback the user
      if (responseMap != null && !responseMap.isEmpty()) {

        // Error messages
        JSONArray jsonErrors = new JSONArray((ArrayList) responseMap.get("errorMessages"));

        // Prepare the Json response
        JSONObject jsonResponse = new JSONObject();
        jsonResponse.put("errorMessages", jsonErrors.toArray());
        jsonResponse.put("errors", responseMap.get("errors"));
        jsonResponse.put("total", responseMap.get("total"));

        // And send it back to the user
        response.getWriter().println(jsonResponse.toString());
      }
    } catch (Exception e) {
      Logger.error(RemotePublishAjaxAction.class, e.getMessage(), e);
      response.sendError(
          HttpStatus.SC_INTERNAL_SERVER_ERROR, "Error Adding content to Bundle: " + e.getMessage());
    }
  }
  /**
   * Allow the user to send or try to send again failed and successfully sent bundles, in order to
   * do that<br>
   * we send the bundle again to que publisher queue job which will try to remote publish again the
   * bundle.
   *
   * @param request HttpRequest
   * @param response HttpResponse
   * @throws IOException If fails sending back to the user a proper response
   * @throws DotPublisherException If fails retrieving the Bundle related information like elements
   *     on it and statuses
   * @throws LanguageException If fails using i18 messages
   */
  public void retry(HttpServletRequest request, HttpServletResponse response)
      throws IOException, DotPublisherException, LanguageException {

    PublisherAPI publisherAPI = PublisherAPI.getInstance();
    PublishAuditAPI publishAuditAPI = PublishAuditAPI.getInstance();

    // Read the parameters
    String bundlesIds = request.getParameter("bundlesIds");
    String[] ids = bundlesIds.split(",");

    StringBuilder responseMessage = new StringBuilder();

    for (String bundleId : ids) {

      if (bundleId.trim().isEmpty()) {
        continue;
      }

      PublisherConfig basicConfig = new PublisherConfig();
      basicConfig.setId(bundleId);
      File bundleRoot = BundlerUtil.getBundleRoot(basicConfig);

      // Get the audit records related to this bundle
      PublishAuditStatus status = PublishAuditAPI.getInstance().getPublishAuditStatus(bundleId);
      String pojo_string = status.getStatusPojo().getSerialized();
      PublishAuditHistory auditHistory = PublishAuditHistory.getObjectFromString(pojo_string);

      // First we need to verify is this bundle is already in the queue job
      List<PublishQueueElement> foundBundles = publisherAPI.getQueueElementsByBundleId(bundleId);
      if (foundBundles != null && !foundBundles.isEmpty()) {
        appendMessage(responseMessage, "publisher_retry.error.already.in.queue", bundleId, true);
        continue;
      }

      // We will be able to retry failed and successfully bundles
      if (!(status.getStatus().equals(Status.FAILED_TO_PUBLISH)
          || status.getStatus().equals(Status.SUCCESS))) {
        appendMessage(responseMessage, "publisher_retry.error.only.failed.publish", bundleId, true);
        continue;
      }

      /*
      Verify if the bundle exist and was created correctly..., meaning, if there is not a .tar.gz file is because
      something happened on the creation of the bundle.
       */
      File bundleFile =
          new File(
              bundleRoot
                  + File.separator
                  + ".."
                  + File.separator
                  + basicConfig.getId()
                  + ".tar.gz");
      if (!bundleFile.exists()) {
        Logger.error(this.getClass(), "No Bundle with id: " + bundleId + " found.");
        appendMessage(responseMessage, "publisher_retry.error.not.found", bundleId, true);
        continue;
      }

      if (!BundlerUtil.bundleExists(basicConfig)) {
        Logger.error(
            this.getClass(), "No Bundle Descriptor for bundle id: " + bundleId + " found.");
        appendMessage(
            responseMessage, "publisher_retry.error.not.descriptor.found", bundleId, true);
        continue;
      }

      try {

        // Read the bundle to see what kind of configuration we need to apply
        String bundlePath = ConfigUtils.getBundlePath() + File.separator + basicConfig.getId();
        File xml = new File(bundlePath + File.separator + "bundle.xml");
        PushPublisherConfig config = (PushPublisherConfig) BundlerUtil.xmlToObject(xml);

        // We can not retry Received Bundles, just bundles that we are trying to send
        Boolean sending = sendingBundle(request, config, bundleId);
        if (!sending) {
          appendMessage(
              responseMessage, "publisher_retry.error.cannot.retry.received", bundleId, true);
          continue;
        }

        if (status.getStatus().equals(Status.SUCCESS)) {

          // Get the bundle
          Bundle bundle = APILocator.getBundleAPI().getBundleById(bundleId);
          if (bundle == null) {
            Logger.error(this.getClass(), "No Bundle with id: " + bundleId + " found.");
            appendMessage(responseMessage, "publisher_retry.error.not.found", bundleId, true);
            continue;
          }
          bundle.setForcePush(true);
          APILocator.getBundleAPI().updateBundle(bundle);
        }

        // Clean the number of tries, we want to try it again
        auditHistory.setNumTries(0);
        publishAuditAPI.updatePublishAuditStatus(
            config.getId(), status.getStatus(), auditHistory, true);

        // Get the identifiers on this bundle
        HashSet<String> identifiers = new HashSet<String>();
        List<PublishQueueElement> assets = config.getAssets();
        if (config.getLuceneQueries() != null && !config.getLuceneQueries().isEmpty()) {
          identifiers.addAll(PublisherUtil.getContentIds(config.getLuceneQueries()));
        }
        if (assets != null && !assets.isEmpty()) {
          for (PublishQueueElement asset : assets) {
            identifiers.add(asset.getAsset());
          }
        }

        // Now depending of the operation lets add it to the queue job
        if (config.getOperation().equals(PushPublisherConfig.Operation.PUBLISH)) {
          publisherAPI.addContentsToPublish(
              new ArrayList<String>(identifiers), bundleId, new Date(), getUser());
        } else {
          publisherAPI.addContentsToUnpublish(
              new ArrayList<String>(identifiers), bundleId, new Date(), getUser());
        }

        // Success...
        appendMessage(responseMessage, "publisher_retry.success", bundleId, false);
      } catch (Exception e) {
        Logger.error(
            this.getClass(),
            "Error trying to add bundle id: " + bundleId + " to the Publishing Queue.",
            e);
        appendMessage(responseMessage, "publisher_retry.error.adding.to.queue", bundleId, true);
      }
    }

    response.getWriter().println(responseMessage.toString());
  }
  /**
   * Generates an Unpublish bundle for a given bundle id operation (publish/unpublish)
   *
   * @param bundleId The Bundle id of the Bundle we want to generate
   * @param operation Download for publish or un-publish
   * @return The generated requested Bundle file
   * @throws DotPublisherException If fails retrieving the Bundle contents
   * @throws DotDataException If fails finding the system user
   * @throws DotPublishingException If fails initializing the Publisher
   * @throws IllegalAccessException If fails creating new Bundlers instances
   * @throws InstantiationException If fails creating new Bundlers instances
   * @throws DotBundleException If fails generating the Bundle
   * @throws IOException If fails compressing the all the Bundle contents into the final Bundle file
   */
  @SuppressWarnings("unchecked")
  private Map<String, Object> generateBundle(
      String bundleId, PushPublisherConfig.Operation operation)
      throws DotPublisherException, DotDataException, DotPublishingException,
          IllegalAccessException, InstantiationException, DotBundleException, IOException {

    PushPublisherConfig pconf = new PushPublisherConfig();
    PublisherAPI pubAPI = PublisherAPI.getInstance();

    List<PublishQueueElement> tempBundleContents = pubAPI.getQueueElementsByBundleId(bundleId);
    List<PublishQueueElement> assetsToPublish =
        new ArrayList<PublishQueueElement>(); // all assets but contentlets

    for (PublishQueueElement c : tempBundleContents) {
      if (!c.getType().equals("contentlet")) {
        assetsToPublish.add(c);
      }
    }

    pconf.setDownloading(true);
    pconf.setOperation(operation);

    // all types of assets in the queue but contentlets are passed here, which are passed through
    // lucene queries
    pconf.setAssets(assetsToPublish);
    // Queries creation
    pconf.setLuceneQueries(PublisherUtil.prepareQueries(tempBundleContents));
    pconf.setId(bundleId);
    pconf.setUser(APILocator.getUserAPI().getSystemUser());

    // BUNDLERS

    List<Class<IBundler>> bundlers = new ArrayList<Class<IBundler>>();
    List<IBundler> confBundlers = new ArrayList<IBundler>();

    Publisher publisher = new PushPublisher();
    publisher.init(pconf);
    // Add the bundles for this publisher
    for (Class clazz : publisher.getBundlers()) {
      if (!bundlers.contains(clazz)) {
        bundlers.add(clazz);
      }
    }

    // Create a new bundle id for this generated bundle
    String newBundleId = UUID.randomUUID().toString();
    pconf.setId(newBundleId);
    File bundleRoot = BundlerUtil.getBundleRoot(pconf);

    // Run bundlers
    BundlerUtil.writeBundleXML(pconf);
    for (Class<IBundler> c : bundlers) {

      IBundler bundler = c.newInstance();
      confBundlers.add(bundler);
      bundler.setConfig(pconf);
      BundlerStatus bundlerStatus = new BundlerStatus(bundler.getClass().getName());
      // Generate the bundler
      bundler.generate(bundleRoot, bundlerStatus);
    }

    pconf.setBundlers(confBundlers);

    // Compressing bundle
    ArrayList<File> list = new ArrayList<File>();
    list.add(bundleRoot);
    File bundle =
        new File(bundleRoot + File.separator + ".." + File.separator + pconf.getId() + ".tar.gz");

    Map<String, Object> bundleData = new HashMap<String, Object>();
    bundleData.put("id", newBundleId);
    bundleData.put("file", PushUtils.compressFiles(list, bundle, bundleRoot.getAbsolutePath()));
    return bundleData;
  }
  /**
   * Send to the publisher queue a list of assets for a given Operation (Publish/Unpublish) and
   * {@link Environment Environment}
   *
   * @param request HttpRequest
   * @param response HttpResponse
   * @throws WorkflowActionFailureException If fails adding the content for Publish
   * @see com.dotcms.publisher.business.PublisherQueueJob
   * @see Environment
   */
  public void publish(HttpServletRequest request, HttpServletResponse response)
      throws IOException, WorkflowActionFailureException {

    try {

      PublisherAPI publisherAPI = PublisherAPI.getInstance();

      // Read the form values
      String _assetId = request.getParameter("assetIdentifier");
      String _contentPushPublishDate = request.getParameter("remotePublishDate");
      String _contentPushPublishTime = request.getParameter("remotePublishTime");
      String _contentPushExpireDate = request.getParameter("remotePublishExpireDate");
      String _contentPushExpireTime = request.getParameter("remotePublishExpireTime");
      String _contentFilterDate = request.getParameter("remoteFilterDate");
      String _iWantTo = request.getParameter("iWantTo");
      String whoToSendTmp = request.getParameter("whoToSend");
      String forcePushStr = request.getParameter("forcePush");
      boolean forcePush = (forcePushStr != null && forcePushStr.equals("true"));
      List<String> whereToSend = Arrays.asList(whoToSendTmp.split(","));
      List<Environment> envsToSendTo = new ArrayList<Environment>();

      // Lists of Environments to push to
      for (String envId : whereToSend) {
        Environment e = APILocator.getEnvironmentAPI().findEnvironmentById(envId);

        if (e != null) {
          envsToSendTo.add(e);
        }
      }

      // Put the selected environments in session in order to have the list of the last selected
      // environments
      request.getSession().setAttribute(WebKeys.SELECTED_ENVIRONMENTS, envsToSendTo);

      SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd-H-m");
      Date publishDate = dateFormat.parse(_contentPushPublishDate + "-" + _contentPushPublishTime);

      List<String> ids;
      if (_assetId.startsWith("query_")) { // Support for lucene queries

        String luceneQuery = _assetId.replace("query_", "");
        List<String> queries = new ArrayList<String>();
        queries.add(luceneQuery);
        ids = PublisherUtil.getContentIds(queries);

      } else {

        String[] _assetsIds =
            _assetId.split(","); // Support for multiple ids in the assetIdentifier parameter
        List<String> assetsIds = Arrays.asList(_assetsIds);

        ids = getIdsToPush(assetsIds, _contentFilterDate, dateFormat);
      }

      // Response map with the status of the addContents operation (error messages and counts )
      Map<String, Object> responseMap = null;

      if (_iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH)
          || _iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH_AND_EXPIRE)) {
        Bundle bundle = new Bundle(null, publishDate, null, getUser().getUserId(), forcePush);
        APILocator.getBundleAPI().saveBundle(bundle, envsToSendTo);

        responseMap =
            publisherAPI.addContentsToPublish(ids, bundle.getId(), publishDate, getUser());
      }
      if (_iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_EXPIRE)
          || _iWantTo.equals(RemotePublishAjaxAction.DIALOG_ACTION_PUBLISH_AND_EXPIRE)) {
        if ((!"".equals(_contentPushExpireDate.trim())
            && !"".equals(_contentPushExpireTime.trim()))) {
          Date expireDate = dateFormat.parse(_contentPushExpireDate + "-" + _contentPushExpireTime);

          Bundle bundle =
              new Bundle(null, publishDate, expireDate, getUser().getUserId(), forcePush);
          APILocator.getBundleAPI().saveBundle(bundle, envsToSendTo);

          responseMap =
              publisherAPI.addContentsToUnpublish(ids, bundle.getId(), expireDate, getUser());
        }
      }

      // If we have errors lets return them in order to feedback the user
      if (responseMap != null && !responseMap.isEmpty()) {

        // Error messages
        JSONArray jsonErrors = new JSONArray((ArrayList) responseMap.get("errorMessages"));

        // Prepare the Json response
        JSONObject jsonResponse = new JSONObject();
        jsonResponse.put("errorMessages", jsonErrors.toArray());
        jsonResponse.put("errors", responseMap.get("errors"));
        jsonResponse.put("total", responseMap.get("total"));
        jsonResponse.put("bundleId", responseMap.get("bundleId"));

        // And send it back to the user
        response.getWriter().println(jsonResponse.toString());
      }
    } catch (Exception e) {
      Logger.error(RemotePublishAjaxAction.class, e.getMessage(), e);
      response.sendError(
          HttpStatus.SC_INTERNAL_SERVER_ERROR, "Error Publishing Bundle: " + e.getMessage());
    }
  }