/*
 * Copyright (C) 2003-2012 eXo Platform SAS.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
package org.exoplatform.services.pdfviewer;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Serializable;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.jcr.Node;

import org.apache.commons.lang3.StringUtils;
import org.exoplatform.container.xml.InitParams;
import org.exoplatform.container.xml.ValueParam;
import org.exoplatform.services.cache.CacheService;
import org.exoplatform.services.cache.ExoCache;
import org.exoplatform.services.cms.impl.Utils;
import org.exoplatform.services.cms.mimetype.DMSMimeTypeResolver;
import org.exoplatform.services.jcr.RepositoryService;
import org.exoplatform.services.log.ExoLogger;
import org.exoplatform.services.log.Log;
import org.icepdf.core.pobjects.Document;

/**
 * Created by The eXo Platform SAS Author : Nguyen The Vinh From ECM Of
 * eXoPlatform vinh_nguyen@exoplatform.com 6 Jul 2012
 */

public class PDFViewerService {
  private static final Log               LOG                      = ExoLogger.getLogger(PDFViewerService.class.getName());

  private static final int               MAX_NAME_LENGTH          = 150;

  public static final long               DEFAULT_MAX_FILE_SIZE    = 10 * 1024 * 1024;

  public static final long               DEFAULT_MAX_PAGES        = 99;

  public static final String             MAX_FILE_SIZE_PARAM_NAME = "maxFileSize";

  public static final String             MAX_PAGES_PARAM_NAME     = "maxPages";

  private static final String CACHE_NAME = "ecms.PDFViewerService";

  private ExoCache<Serializable, Object> pdfCache;

  private long                           maxFileSize;

  private long                           maxPages;

  public PDFViewerService(RepositoryService repositoryService,
                          CacheService caService,
                          InitParams initParams) throws Exception {
    pdfCache = caService.getCacheInstance(CACHE_NAME);

    maxFileSize = DEFAULT_MAX_FILE_SIZE;
    maxPages = DEFAULT_MAX_PAGES;
    if (initParams != null) {
      ValueParam maxFileSizeValueParam = initParams.getValueParam(MAX_FILE_SIZE_PARAM_NAME);
      if (maxFileSizeValueParam != null) {
        try {
          maxFileSize = Long.parseLong(maxFileSizeValueParam.getValue()) * 1024 * 1024;
        } catch (NumberFormatException e) {
          LOG.warn("Parameter " + MAX_FILE_SIZE_PARAM_NAME + " for document preview is not a valid number ("
              + maxFileSizeValueParam.getValue() + "), default value will be used (" + DEFAULT_MAX_FILE_SIZE + ")");
        }
      }
      ValueParam maxPagesValueParam = initParams.getValueParam(MAX_PAGES_PARAM_NAME);
      if (maxPagesValueParam != null) {
        try {
          maxPages = Long.parseLong(maxPagesValueParam.getValue());
        } catch (NumberFormatException e) {
          LOG.warn("Parameter " + MAX_PAGES_PARAM_NAME + " for document preview is not a valid number ("
              + maxPagesValueParam.getValue() + "), default value will be used (" + MAX_PAGES_PARAM_NAME + ")");
        }
      }
    }
  }

  public long getMaxFileSize() {
    return maxFileSize;
  }

  public long getMaxPages() {
    return maxPages;
  }

  public ExoCache<Serializable, Object> getCache() {
    return pdfCache;
  }

  /**
   * Init pdf document from InputStream in nt:file node
   * 
   * @param currentNode
   * @param repoName
   * @return
   * @throws Exception
   */
  public Document initDocument(Node currentNode, String repoName) throws Exception {
    return buildDocumentImage(getPDFDocumentFile(currentNode, repoName), currentNode.getName());
  }

  public Document buildDocumentImage(File input, String name) {
    Document document = new Document();

    // Turn off Log of org.icepdf.core.pobjects.Document to avoid printing error
    // stack trace in case viewing
    // a PDF file which use new Public Key Security Handler.
    // TODO: Remove this statement after IcePDF fix this
    Logger.getLogger(Document.class.toString()).setLevel(Level.OFF);

    if (input == null)
      return null;

    // Capture the page image to file
    try {
      // cut the file name if name is too long, because OS allows only file with
      // name < 250 characters
      name = reduceFileNameSize(name);
      FileInputStream fis = new FileInputStream(input);
      document.setInputStream(new BufferedInputStream(fis), name);
      return document;
    } catch (Exception ex) {
      LOG.warn("Failed to build Document image from pdf file " + name);
      if (LOG.isDebugEnabled()) {
        LOG.debug(ex);
      }
      return null;
    }
  }

  /**
   * Write PDF data to file
   * 
   * @param currentNode
   * @param repoName
   * @return
   * @throws Exception
   */
  public File getPDFDocumentFile(Node currentNode, String repoName) throws Exception {
    String wsName = currentNode.getSession().getWorkspace().getName();
    String uuid = currentNode.getUUID();
    StringBuilder bd = new StringBuilder();
    StringBuilder bd1 = new StringBuilder();
    StringBuilder bd2 = new StringBuilder();
    bd.append(repoName).append("/").append(wsName).append("/").append(uuid);
    bd1.append(bd).append("/jcr:lastModified");
    bd2.append(bd).append("/jcr:baseVersion");
    String path = (String) pdfCache.get(new ObjectKey(bd.toString()));
    String lastModifiedTime = (String) pdfCache.get(new ObjectKey(bd1.toString()));
    String cachedBaseVersion = (String) pdfCache.get(new ObjectKey(bd2.toString()));
    File content = null;
    String name = currentNode.getName().replaceAll(":", "_");
    Node contentNode = currentNode.getNode("jcr:content");

    String lastModified = Utils.getJcrContentLastModified(currentNode);
    String baseVersion = Utils.getJcrContentBaseVersion(currentNode);
    if (path == null || !(content = new File(path)).exists() || !lastModified.equals(lastModifiedTime) ||
            !StringUtils.equals(baseVersion, cachedBaseVersion)) {
      String mimeType = contentNode.getProperty("jcr:mimeType").getString();
      InputStream input = new BufferedInputStream(contentNode.getProperty("jcr:data").getStream());
      // Create temp file to store converted data of nt:file node
      if (name.indexOf(".") > 0)
        name = name.substring(0, name.lastIndexOf("."));
      // cut the file name if name is too long, because OS allows only file with
      // name < 250 characters
      name = reduceFileNameSize(name);
      content = File.createTempFile(name + "_tmp", ".pdf");

      // Convert to pdf if need
      String extension = DMSMimeTypeResolver.getInstance().getExtension(mimeType);
      if ("pdf".equals(extension)) {
        read(input, new BufferedOutputStream(new FileOutputStream(content)));
      }
      if (content.exists()) {
        if (contentNode.hasProperty("jcr:lastModified")) {
          pdfCache.put(new ObjectKey(bd.toString()), content.getPath());
          pdfCache.put(new ObjectKey(bd1.toString()), lastModified);
        }
        pdfCache.put(new ObjectKey(bd2.toString()), baseVersion);
      }
    }
    return content;
  }

  /**
   * reduces the file name size. If the length is > 150, return the first 150
   * characters, else, return the original value
   * 
   * @param name the name
   * @return the reduced name
   */
  private String reduceFileNameSize(String name) {
    return (name != null && name.length() > MAX_NAME_LENGTH) ? name.substring(0, MAX_NAME_LENGTH) : name;
  }

  private void read(InputStream is, OutputStream os) throws Exception {
    int bufferLength = 1024;
    int readLength = 0;
    while (readLength > -1) {
      byte[] chunk = new byte[bufferLength];
      readLength = is.read(chunk);
      if (readLength > 0) {
        os.write(chunk, 0, readLength);
      }
    }
    os.flush();
    os.close();
  }
}
