/*
 *  Copyright 2017 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.plugins.extraction.edition;

import java.io.File;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;

import javax.xml.transform.OutputKeys;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.xml.XMLUtils;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.apache.excalibur.source.impl.FileSource;
import org.apache.xml.serializer.OutputPropertiesFactory;

import org.ametys.core.ui.Callable;
import org.ametys.core.ui.StaticClientSideElement;
import org.ametys.plugins.extraction.ExtractionConstants;

/**
 * This client site element manages a button to create an extraction definition file
 */
public class EditExtractionClientSideElement extends StaticClientSideElement
{
    /** The Avalon role name */
    public static final String ROLE = EditExtractionClientSideElement.class.getName();
    
    private SourceResolver _sourceResolver;
    
    @Override
    public void service(ServiceManager serviceManager) throws ServiceException
    {
        super.service(serviceManager);
        _sourceResolver = (SourceResolver) serviceManager.lookup(SourceResolver.ROLE);
    }

    /**
     * Creates an extraction definition file.
     * @param definitionFileName The extraction definition name
     * @return Map containing success boolean and error codes if one occurs
     * @throws Exception if an error occurs
     */
    @Callable (right = "Extraction_Rights_EditExtraction")
    public Map<String, Object> createExtraction(String definitionFileName) throws Exception
    {
        Map<String, Object> response = new LinkedHashMap<>();
        
        // Create extraction definitions directory
        Source definitionsSrc = _sourceResolver.resolveURI(ExtractionConstants.DEFINITIONS_DIR);
        File definitionsDir = ((FileSource) definitionsSrc).getFile();
        definitionsDir.mkdirs();
        
        String definitionFilePath = ExtractionConstants.DEFINITIONS_DIR + definitionFileName;
        Source definitionSrc = _sourceResolver.resolveURI(definitionFilePath);
        File definitionFile = ((FileSource) definitionSrc).getFile();

        if (definitionFile.exists())
        {
            if (getLogger().isErrorEnabled())
            {
                getLogger().error("A definition file already exists with name '" + definitionFileName + "'");
            }
            response.put("success", false);
            response.put("error", "already-exists");
            return response;
        }
        
        try (OutputStream os = Files.newOutputStream(Paths.get(definitionFile.getAbsolutePath())))
        {
            // Create a transformer for saving sax into a file
            TransformerHandler handler = ((SAXTransformerFactory) TransformerFactory.newInstance()).newTransformerHandler();
            
            StreamResult result = new StreamResult(os);
            handler.setResult(result);

            // create the format of result
            Properties format = new Properties();
            format.put(OutputKeys.METHOD, "xml");
            format.put(OutputKeys.INDENT, "yes");
            format.put(OutputKeys.ENCODING, "UTF-8");
            format.put(OutputPropertiesFactory.S_KEY_INDENT_AMOUNT, "4");
            handler.getTransformer().setOutputProperties(format);

            // sax skeleton
            handler.startDocument();
            XMLUtils.createElement(handler, "extraction");
            handler.endDocument();
        }
        catch (Exception e)
        {
            if (getLogger().isErrorEnabled())
            {
                getLogger().error("Error when trying to create the extraction definition file '" + definitionFileName + "'", e);
            }
            response.put("success", false);
            response.put("error", "other-error");
            return response;
        }
        
        response.put("success", true);
        return response;
    }
    
    /**
     * Renames an extraction definition file.
     * @param definitionOldFileName The extraction definition old file name
     * @param definitionNewFileName The extraction definition new file name
     * @return Map containing success boolean and error codes if one occurs
     * @throws Exception if an error occurs
     */
    @Callable (right = "Extraction_Rights_EditExtraction")
    public Map<String, Object> renameExtraction(String definitionOldFileName, String definitionNewFileName) throws Exception
    {
        Map<String, Object> response = new LinkedHashMap<>();
        
        String oldFilePath = ExtractionConstants.DEFINITIONS_DIR + definitionOldFileName;
        Source oldSrc = _sourceResolver.resolveURI(oldFilePath);
        File oldFile = ((FileSource) oldSrc).getFile();
        
        if (!oldFile.exists())
        {
            if (getLogger().isErrorEnabled())
            {
                getLogger().error("Error while renaming '" + definitionOldFileName + "': this definition file doesn't exist.");
            }
            response.put("success", false);
            response.put("error", "unexisting");
            return response;
        }
        
        String newFilePath = ExtractionConstants.DEFINITIONS_DIR + definitionNewFileName;
        Source newSrc = _sourceResolver.resolveURI(newFilePath);
        File newFile = ((FileSource) newSrc).getFile();
        
        if (newFile.exists())
        {
            if (getLogger().isErrorEnabled())
            {
                getLogger().error("Error while renaming to '" + definitionNewFileName + "': a definition file with this name already exists.");
            }
            response.put("success", false);
            response.put("error", "already-exists");
            return response;
        }

        // Copy old file in the new one
        try
        {
            Files.copy(oldFile.toPath(), newFile.toPath());
        }
        catch (IOException e)
        {
            if (getLogger().isErrorEnabled())
            {
                getLogger().error("Error while copying old definition file '" + definitionOldFileName + "' in the new one.", e);
            }
            response.put("success", false);
            response.put("error", "other-error");
            return response;
        }
        
        try
        {
            Files.deleteIfExists(oldFile.toPath());
        }
        catch (IOException e)
        {
            if (getLogger().isErrorEnabled())
            {
                getLogger().error("Error while deleting old definition file '" + definitionOldFileName + "'.", e);
            }
            response.put("success", false);
            response.put("error", "other-error");
            return response;
        }
        
        response.put("success", true);
        return response;
    }
    
    /**
     * Deletes an extraction definition file.
     * @param definitionFileName The extraction definition file to delete
     * @return <code>true</code> if extraction deletion succeed, <code>false</code> otherwise
     * @throws Exception if an error occurs
     */
    @Callable (right = "Extraction_Rights_EditExtraction")
    public boolean deleteExtraction(String definitionFileName) throws Exception
    {
        String filePath = ExtractionConstants.DEFINITIONS_DIR + definitionFileName;
        Source source = _sourceResolver.resolveURI(filePath);
        File file = ((FileSource) source).getFile();
        
        if (!file.exists())
        {
            throw new IllegalArgumentException("Error while deleting '" + definitionFileName + "': this definition file doesn't exist.");
        }
        
        try
        {
            Files.deleteIfExists(file.toPath());
        }
        catch (IOException e)
        {
            if (getLogger().isErrorEnabled())
            {
                getLogger().error("Error while deleting definition file '" + definitionFileName + "'.", e);
            }
            throw e;
        }
        
        return true;
    }

}