/*
 *  Copyright 2013 Anyware Services
 *
 *  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.ametys.site;

import java.io.File;
import java.io.IOException;

import org.apache.cocoon.ProcessingException;
import org.apache.cocoon.components.source.SourceUtil;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceException;
import org.apache.excalibur.source.impl.FileSource;

import org.ametys.core.util.URLEncoder;
import org.ametys.runtime.config.Config;
import org.ametys.runtime.servlet.RuntimeConfig;

/**
 * Class providing helper methods for cache files.
 */
public final class SiteCacheHelper
{
    
    private static final String __MD5_PREFIX = "md5$";
    
    private SiteCacheHelper()
    {
        // Hidden.
    }
    
    /**
     * Return the root cache file
     * @return The root cache File
     */
    public static File getRootCache()
    {
        return new File(RuntimeConfig.getInstance().getAmetysHome(), "cache");
    }
    
    /**
     * Test if a file is valid.
     * @param file the file to test.
     * @return true if the file is valid, false otherwise.
     */
    public static boolean isValid(File file)
    {
        boolean valid = true;
        
        long maxLength = Config.getInstance().getValue("org.ametys.site.cache.max.filename.length");
        
        try
        {
            file.getCanonicalPath();
            file.toURI();
            
            valid = file.getName().length() <= maxLength;
            
            File parent = file.getParentFile();
            while (valid && parent != null)
            {
                valid = parent.getName().length() <= maxLength;
                parent = parent.getParentFile();
            }
        }
        catch (IOException e)
        {
            valid = false;
        }
        
        return valid;
    }
    
    /**
     * Test if a file source is valid.
     * @param fileSource the file source to test.
     * @return true if the file is valid, false otherwise.
     */
    public static boolean isValid(FileSource fileSource)
    {
        return isValid(fileSource.getFile());
    }
    
    /**
     * Get a hashed file path for the given file.
     * @param file the original resource file.
     * @return the hashed file path.
     */
    public static String getHashedFilePath(File file)
    {
        return getHashedFilePath(file, false);
    }
    
    /**
     * Get a hashed file path for the given file.
     * @param file the original resource file.
     * @param encode true to encode the folder parts, false otherwise.
     * @return the hashed file path.
     */
    public static String getHashedFilePath(File file, boolean encode)
    {
        return getHashedFilePath(file.getPath(), encode);
    }
    
    /**
     * Get a hashed version of the given file path.
     * @param filePath the original file path.
     * @return the hashed file path.
     */
    public static String getHashedFilePath(String filePath)
    {
        return getHashedFilePath(filePath, false);
    }
    
    /**
     * Get a hashed version of the given file path.
     * @param filePath the original file path.
     * @param encode true to encode the folder parts, false otherwise.
     * @return the hashed file path.
     */
    public static String getHashedFilePath(String filePath, boolean encode)
    {
        long maxLength = Config.getInstance().getValue("org.ametys.site.cache.max.filename.length");
        
        String prefix = FilenameUtils.getPrefix(filePath);
        String basePath = FilenameUtils.getPath(filePath);
        String baseName = FilenameUtils.getBaseName(filePath);
        String name = FilenameUtils.getName(filePath);
        
        String encodedBasePath = hashPath(basePath, encode);
        
        if (name.length() > maxLength)
        {
            String extension = FilenameUtils.getExtension(filePath);
            name = __MD5_PREFIX + DigestUtils.md5Hex(baseName) + "." + extension;
        }
        
        String validPath = prefix + encodedBasePath + name;
        
        return validPath;
    }
    
    /**
     * Release the given file source and resolve a hashed version of the file to replace it.
     * @param resolver the source resolver.
     * @param source the invalid file source to hash.
     * @return the hashed file source.
     * @throws IOException if an IO error occurs.
     * @throws ProcessingException if the new source couldn't be resolved.
     */
    public static Source getHashedFileSource(SourceResolver resolver, FileSource source) throws IOException, ProcessingException
    {
        File file = source.getFile();
        
        String validPath = SiteCacheHelper.getHashedFilePath(file, true);
        String prefix = source.getScheme() + ":";
        
        try
        {
            // Release the old source
            resolver.release(source);
            
            // Resolve the new source.
            return resolver.resolveURI(prefix + validPath);
        }
        catch (SourceException e)
        {
            throw SourceUtil.handle("Error during resolving of '" + validPath + "'.", e);
        }
    }
    
    /**
     * Hash the resource path
     * @param path the resource path
     * @param encode true to encode the un-hashed paths, false otherwise.
     * @return the hashed and encoded URI
     */
    private static String hashPath(String path, boolean encode)
    {
        long maxLength = Config.getInstance().getValue("org.ametys.site.cache.max.filename.length");
        
        StringBuilder sb = new StringBuilder();
        
        String[] parts = StringUtils.split(path, "/\\");
        for (int i = 0; i < parts.length; i++)
        {
            if (i > 0 || path.charAt(0) == File.separatorChar)
            {
                sb.append(File.separatorChar);
            }
            
            if (parts[i].length() > maxLength)
            {
                // Hash the path part.
                sb.append(__MD5_PREFIX).append(DigestUtils.md5Hex(parts[i]));
            }
            else if (encode)
            {
                // Encode the path part.
                sb.append(URLEncoder.encodePath(parts[i]));
            }
            else
            {
                // Leave the path part as is.
                sb.append(parts[i]);
            }
        }
        
        if (sb.charAt(sb.length() - 1) != File.separatorChar)
        {
            sb.append(File.separatorChar);
        }
        
        return sb.toString();
    }
    
}