/*
 *  Copyright 2011 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.web.skin.actions;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import org.apache.avalon.framework.context.Context;
import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.context.Contextualizable;
import org.apache.avalon.framework.parameters.Parameters;
import org.apache.cocoon.Constants;
import org.apache.cocoon.acting.ServiceableAction;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Redirector;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.environment.SourceResolver;
import org.apache.cocoon.servlet.multipart.Part;
import org.apache.cocoon.servlet.multipart.PartOnDisk;
import org.apache.cocoon.servlet.multipart.RejectedPart;
import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
import org.apache.commons.compress.archivers.zip.ZipFile;
import org.apache.commons.io.FileUtils;
import org.apache.tika.io.IOUtils;

import org.ametys.core.cocoon.JSonReader;
import org.ametys.runtime.util.AmetysHomeHelper;

/**
 * This action receive a form with the "importfile" zip file as an exported skin.
 * Replace existing skin 
 */
public class UploadSkinAction extends ServiceableAction implements Contextualizable
{
    /** The cocoon context */
    protected org.apache.cocoon.environment.Context _cocoonContext;

    @Override
    public void contextualize(Context context) throws ContextException
    {
        _cocoonContext = (org.apache.cocoon.environment.Context) context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
        
    @Override
    public Map act(Redirector redirector, SourceResolver resolver, Map objectModel, String source, Parameters parameters) throws Exception
    {
        Request request = ObjectModelHelper.getRequest(objectModel);
        
        Map<String, Object> result = new LinkedHashMap<>();

        boolean isModel = parameters.getParameterAsBoolean("model", false);
        try
        {
            // Checking file
            Part part = (Part) request.get("importfile");
            if (part instanceof RejectedPart || part == null)
            {
                result.put("success", false);
                result.put("error", "rejected");
            }
            else
            {
                // Getting file
                PartOnDisk uploadedFilePart = (PartOnDisk) part;
                File uploadedFile = uploadedFilePart.getFile();
                
                String filename = (String) uploadedFilePart.getHeaders().get("filename");
                String skinName = filename.substring(0, filename.length() - 4);
                
                if (getLogger().isDebugEnabled())
                {
                    getLogger().debug("Uploading skin " + skinName);
                }
    
                // Unzipping in tmp
                File dir = _unzip(uploadedFile);
                
                // Filter files
                _filter(dir, dir.getAbsolutePath(), isModel);
                
                // Test if the configuration model file is present.
                File configFile = new File(dir, "stylesheets" + File.separator + "config" + File.separator + "config-model.xml");
                
                result.put("skinDir", dir.getName());
                result.put("tempDir", dir.getParentFile().getName());
                result.put("hasConfig", configFile.isFile());
                result.put("skinName", skinName);
                result.put("success", "true");
            }
        }
        catch (Exception e)
        {
            getLogger().error("Unable to add skin", e);
            result.put("success", false);
            
            Map<String, String> ex = new HashMap<>();
            ex.put("message", e.getMessage());

            result.put("error", ex);
        }
        
        request.setAttribute(JSonReader.OBJECT_TO_READ, result);
        
        return result;    
    }

    /**
     * Unzip file in temp directory
     * @param uploadedFile the uploaded file
     * @return the unzipped file
     * @throws IOException if an I/O exception occurs
     */
    protected File _unzip(File uploadedFile) throws IOException
    {
        File tmpFile = new File(AmetysHomeHelper.getAmetysHomeTmp(), Long.toString(Math.round(Math.random() * 1000000.0)));
        
        getLogger().debug("Importing skin in tmp dir " + tmpFile.getAbsolutePath());
        ZipFile zipFile = new ZipFile(uploadedFile, "cp437");
        
        try
        {
            Enumeration<ZipArchiveEntry> entries = zipFile.getEntries();
            while (entries.hasMoreElements())
            {
                ZipArchiveEntry zipEntry = entries.nextElement();
                
                String zipName = zipEntry.getName();
    
                if (zipEntry.isDirectory())
                {
                    File newDir = new File(tmpFile, zipName);
                    newDir.mkdirs();
                }
                else
                {
                    InputStream is = null;
                    FileOutputStream fos = null;
                    
                    try
                    {
                        is = zipFile.getInputStream(zipEntry);
                        File newFile = new File(tmpFile, zipName);
                        newFile.getParentFile().mkdirs();
                        fos = new FileOutputStream(newFile);
                        
                        IOUtils.copy(is, fos);
                    }
                    finally
                    {
                        IOUtils.closeQuietly(is);
                        IOUtils.closeQuietly(fos);
                    }
                }
            }
        }
        finally
        {
            ZipFile.closeQuietly(zipFile);
        }
        
        File[] files = tmpFile.listFiles();
        if (files.length != 1 || !files[0].isDirectory())
        {
            throw new IllegalArgumentException("An imported skin or model must be a zip with a single root directory");
        }
        
        return files[0];
    }
    
    /**
     * Filter skin directory
     * @param skinDir the skin directory
     * @param absoluteSkinPath the absolute path of tmp skin directory
     * @param isModel true if the uploaded skin is the model of skin.
     * @throws IOException if an error occurred
     */
    protected void _filter(File skinDir, String absoluteSkinPath, boolean isModel) throws IOException
    {
        File[] files = skinDir.listFiles();
        for (File file : files)
        {
            if (file.isDirectory())
            {
                if ("CVS".equals(file.getName()) || ".svn".equals(file.getName()) || (!isModel && "model".equals(file.getName())))
                {
                    FileUtils.deleteQuietly(file);
                }
                else
                {
                    _filter(file, absoluteSkinPath, isModel);
                }
            }
        }
    }
}