/*
 *  Copyright 2010 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.cms.transformation.htmledition;

import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.util.Date;
import java.util.HashSet;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

import org.apache.avalon.framework.context.ContextException;
import org.apache.avalon.framework.service.ServiceException;
import org.apache.avalon.framework.service.ServiceManager;
import org.apache.cocoon.Constants;
import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.Context;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.apache.cocoon.environment.Request;
import org.apache.cocoon.xml.AttributesImpl;
import org.apache.commons.io.IOUtils;
import org.apache.commons.io.output.ByteArrayOutputStream;
import org.apache.excalibur.source.Source;
import org.apache.excalibur.source.SourceResolver;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;

import org.ametys.cms.data.NamedResource;
import org.ametys.cms.data.RichText;
import org.ametys.core.upload.Upload;
import org.ametys.core.upload.UploadManager;
import org.ametys.core.user.CurrentUserProvider;
import org.ametys.core.util.DateUtils;
import org.ametys.core.util.ImageHelper;
import org.ametys.plugins.explorer.resources.Resource;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.metadata.File;
import org.ametys.plugins.repository.metadata.ModifiableFile;
import org.ametys.plugins.repository.metadata.ModifiableFolder;
import org.ametys.plugins.repository.metadata.ModifiableResource;
import org.ametys.plugins.repository.metadata.ModifiableRichText;

/**
 * This transformer extracts uploaded files' ids from the incoming HTML for further processing.
 */
public class UploadedDataHTMLEditionHandler extends AbstractHTMLEditionHandler
{
    private static final Pattern __INLINE_IMAGE_MARKER = Pattern.compile("^data:image/(png|jpeg|gif);base64,.*");
    
    private UploadManager _uploadManager;
    private CurrentUserProvider _userProvider;
    private SourceResolver _resolver;
    private AmetysObjectResolver _ametysResolver;
    private Context _cocoonContext;
    
    private boolean _tagToIgnore;
    private Set<String> _usedLocalFiles = new HashSet<>();
    private Object _richText; // FIXME only handle org.ametys.cms.data.RichText when old API will finally be removed
    private Map _objectModel;


    @Override
    public void contextualize(org.apache.avalon.framework.context.Context context) throws ContextException
    {
        super.contextualize(context);
        _cocoonContext = (Context) _context.get(Constants.CONTEXT_ENVIRONMENT_CONTEXT);
    }
    
    @Override
    public void service(ServiceManager sManager) throws ServiceException
    {
        super.service(sManager);
        _uploadManager = (UploadManager) sManager.lookup(UploadManager.ROLE);
        _userProvider = (CurrentUserProvider) sManager.lookup(CurrentUserProvider.ROLE);
        _resolver = (SourceResolver) sManager.lookup(SourceResolver.ROLE);
        _ametysResolver = (AmetysObjectResolver) sManager.lookup(AmetysObjectResolver.ROLE);
    }
    
    @Override
    public void startDocument() throws SAXException
    {
        _tagToIgnore = false;
        _objectModel = ContextHelper.getObjectModel(_context);
        Map parentContextParameters = (Map) _objectModel.get(ObjectModelHelper.PARENT_CONTEXT);
        _richText = parentContextParameters.get("richText");
        
        super.startDocument();
    }
    
    @Override
    public void startElement(String uri, String loc, String raw, Attributes attrs) throws SAXException
    {
        if ("img".equals(raw))
        {
            String type = attrs.getValue("data-ametys-type");
            
            if ("temp".equals(type))
            {
                Attributes newAttrs = _getAttributesForTemp(attrs);
                super.startElement(uri, loc, raw, newAttrs);
                return;
            }
            else if ("explorer".equals(type))
            {
                Attributes newAttrs = _processResource(attrs);
                super.startElement(uri, loc, raw, newAttrs);
                return;
            }
            else if ("local".equals(type))
            {
                Attributes newAttrs = _processLocal(attrs);
                super.startElement(uri, loc, raw, newAttrs);
                return;
            }
            else if (type == null && !"marker".equals(attrs.getValue("marker")))
            {
                // image is copied from elsewhere, fetch it in the content
                String src = attrs.getValue("src");
                if (src == null)
                {
                    _tagToIgnore = true;
                    getLogger().warn("Don't know how to fetch image with no src attribute. Image is ignored.");
                    return;
                }
                
                // The final filename
                String fileName = null;
                // The new attributes, will be filled with image width and height.
                AttributesImpl newAttrs = new AttributesImpl();

                Matcher m = __INLINE_IMAGE_MARKER.matcher(src);
                if (m.matches())
                {
                    String mimetype = m.group(1);
                    String imageAsBase64 = src.substring(19 + mimetype.length());
                    byte[] imageAsBytes = org.apache.commons.codec.binary.Base64.decodeBase64(imageAsBase64);
                    fileName = _storeFile("paste." + mimetype, new ByteArrayInputStream(imageAsBytes), null, null);
                    
                    try (InputStream is = new ByteArrayInputStream(imageAsBytes))
                    {
                        _addDimensionAttributes(is, newAttrs);
                    }
                    catch (IOException e)
                    {
                        // Ignore
                    }
                }
                else
                {
                    
                    String initialFileName = _getInitialFileName(src);
                    
                    if (src.startsWith("/"))
                    {
                        try
                        {
                            fileName = _handleInternalFile(src, newAttrs, initialFileName);
                        }
                        catch (Exception e)
                        {
                            // unable to fetch image, do not keep the img tag
                            _tagToIgnore = true;
                            getLogger().warn("Unable to fetch internal image from URL '" + src + "'. Image is ignored.", e);
                            return;
                        }
                    }
                    else if (src.startsWith("http://") || src.startsWith("https://"))
                    {
                        try
                        {
                            fileName = _handleRemoteFile(src, newAttrs, initialFileName);
                        }
                        catch (Exception e)
                        {
                            // unable to fetch image, do not keep the img tag
                            _tagToIgnore = true;
                            getLogger().warn("Unable to fetch external image from URL '" + src + "'. Image is ignored.", e);
                            return;
                        }
                    }
                    else
                    {
                        _tagToIgnore = true;
                        getLogger().warn("Don't know how to fetch image at '" + src + "'. Image is ignored.");
                        return;
                    }
                }
                    
                _copyAttributes(attrs, newAttrs);
                
                newAttrs.addAttribute("", "data-ametys-src", "data-ametys-src", "CDATA", fileName);
                newAttrs.addAttribute("", "data-ametys-type", "data-ametys-type", "CDATA", "local");
                
                super.startElement(uri, loc, raw, newAttrs);
                return;
            }
        }
        
        super.startElement(uri, loc, raw, attrs);
    }
    
    private String _getInitialFileName(String src)
    {
        int j = src.lastIndexOf('/');
        int k = src.indexOf('?', j);
        String initialFileName;
        
        if (k == -1)
        {
            initialFileName = src.substring(j + 1);
        }
        else
        {
            initialFileName = src.substring(j + 1, k);
        }
        
        // FIXME CMS-3090 A uploaded image can not contain '_max' or '_crop', replace it by '_Max', '_Crop'
        return initialFileName.replaceAll("_max", "_Max").replaceAll("_crop", "_Crop");
    }

    private String _handleInternalFile(String src, AttributesImpl newAttrs, String initialFileName) throws MalformedURLException, IOException, URISyntaxException
    {
        // it may be an internal URL
        Request request = ContextHelper.getRequest(_context);
        String contextPath = request.getContextPath();
        Source source = null;
        
        try
        {
            String modifiedSrc = src;
            
            if (src.startsWith(contextPath))
            {
                // it is an Ametys URL
                // first decode it
                modifiedSrc = new URI(modifiedSrc).getPath();
                
                modifiedSrc = "cocoon:/" + src.substring(contextPath.length());
            }
            else
            {
                StringBuilder sb = _getRequestURI(request);
                
                modifiedSrc = sb.toString() + modifiedSrc;
            }
            
            source = _resolver.resolveURI(src);
            
            try (ByteArrayOutputStream bos = new ByteArrayOutputStream())
            {
                try (InputStream is = source.getInputStream())
                {
                    IOUtils.copy(is, bos);
                }
                
                String fileName = _storeFile(initialFileName, new ByteArrayInputStream(bos.toByteArray()), null, null);
                
                try (InputStream is = new ByteArrayInputStream(bos.toByteArray()))
                {
                    _addDimensionAttributes(is, newAttrs);
                }
                
                return fileName;
            }
        }
        finally
        {
            if (source != null)
            {
                _resolver.release(source);
            }
        }

    }
    
    private String _handleRemoteFile(String src, AttributesImpl newAttrs, String initialFileName) throws MalformedURLException, IOException
    {
        String fileName;
        URL url = new URL(src);
        HttpURLConnection connection = (HttpURLConnection) url.openConnection();
        connection.setRequestProperty("User-Agent", "Mozilla"); // some servers only answer to browsers ...
        connection.setConnectTimeout(1000);
        connection.setReadTimeout(2000);
        
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream())
        {
            try (InputStream is = connection.getInputStream())
            {
                IOUtils.copy(is, bos);
            }
            
            fileName = _storeFile(initialFileName, new ByteArrayInputStream(bos.toByteArray()), null, null);
            
            try (InputStream is = new ByteArrayInputStream(bos.toByteArray()))
            {
                _addDimensionAttributes(is, newAttrs);
            }
        }
        return fileName;
    }
    
    /**
     * Copy the attributes.
     * @param attrs the attributes to copy.
     * @param newAttrs the attributes to copy to.
     */
    private void _copyAttributes(Attributes attrs, AttributesImpl newAttrs)
    {
        for (int i = 0; i < attrs.getLength(); i++)
        {
            String name = attrs.getQName(i);
            
            if (!"data-ametys-src".equals(name) && !"data-ametys-type".equals(name))
            {
                newAttrs.addAttribute(attrs.getURI(i), attrs.getLocalName(i), name, attrs.getType(i), attrs.getValue(i));
            }
        }
    }

    /**
     * Get the cms uri
     * @param request The request
     * @return the uri without context path
     */
    private StringBuilder _getRequestURI(Request request)
    {
        StringBuilder sb = new StringBuilder();
        sb.append(request.getScheme());
        sb.append("://");
        sb.append(request.getServerName());
        
        if (request.isSecure())
        {
            if (request.getServerPort() != 443)
            {
                sb.append(":");
                sb.append(request.getServerPort());
            }
        }
        else
        {
            if (request.getServerPort() != 80)
            {
                sb.append(":");
                sb.append(request.getServerPort());
            }
        }
        return sb;
    }

    private Attributes _getAttributesForTemp(Attributes attrs)
    {
        // data has just been uploaded, must change the value, and store the id for further processing
        String id = attrs.getValue("data-ametys-temp-src");
        
        Upload upload = _uploadManager.getUpload(_userProvider.getUser(), id);
        
        String initialFileName = upload.getFilename();
        // FIXME CMS-3090 A uploaded image can not contain '_max', replace it by '_Max'
        initialFileName = initialFileName.replaceAll("_max", "_Max").replaceAll("_crop", "_Crop");
        String fileName = _storeFile(initialFileName, upload.getInputStream(), upload.getMimeType(), upload.getUploadedDate());
        
        AttributesImpl newAttrs = new AttributesImpl();
        
        _copyAttributes(attrs, newAttrs);
        
        if (!"marker".equals(attrs.getValue("marker")))
        {
            try (InputStream is = upload.getInputStream())
            {
                _addDimensionAttributes(is, newAttrs);
            }
            catch (IOException e)
            {
                // Ignore
            }
        }
        
        newAttrs.addAttribute("", "data-ametys-src", "data-ametys-src", "CDATA", fileName);
        newAttrs.addAttribute("", "data-ametys-type", "data-ametys-type", "CDATA", "local");
        
        return newAttrs;
    }
    
    /**
     * Store a file as rich text data.
     * @param initialFileName the initial file name.
     * @param is an input stream on the file.
     * @param mimeType the file mime type.
     * @param lastModified the last modification date.
     * @return the final file name.
     */
    protected String _storeFile(String initialFileName, InputStream is, String mimeType, ZonedDateTime lastModified)
    {
        String fileName = initialFileName;
        int count = 2;
        
        if (_richText instanceof RichText)
        {
            RichText richText = (RichText) _richText;
            
            while (richText.hasAttachment(fileName))
            {
                int i = initialFileName.lastIndexOf('.');
                fileName = i == -1 ? initialFileName + '-' + (count++) : initialFileName.substring(0, i) + '-' + (count++) + initialFileName.substring(i);
            }
        
            NamedResource resource = new NamedResource();
    
            String finalMimeType = mimeType != null ? mimeType : _cocoonContext.getMimeType(fileName.toLowerCase());
            resource.setMimeType(finalMimeType != null ? finalMimeType : "application/unknown");
            
            resource.setFilename(fileName);
            resource.setLastModificationDate(lastModified != null ? lastModified : ZonedDateTime.now(ZoneOffset.UTC));
            
            try
            {
                resource.setInputStream(is);
            }
            catch (IOException e)
            {
                throw new AmetysRepositoryException("Unable to save attachment " + initialFileName, e);
            }
        
            richText.addAttachment(resource);
        }
        else
        {
            ModifiableRichText richText = (ModifiableRichText) _richText;
            
            while (richText.getAdditionalDataFolder().hasFile(fileName))
            {
                int i = initialFileName.lastIndexOf('.');
                fileName = i == -1 ? initialFileName + '-' + (count++) : initialFileName.substring(0, i) + '-' + (count++) + initialFileName.substring(i);
            }
            
            ModifiableFile file = richText.getAdditionalDataFolder().addFile(fileName);
            ModifiableResource resource = file.getResource();
            resource.setLastModified(Optional.ofNullable(lastModified).map(DateUtils::asDate).orElseGet(Date::new));
            
            String finalMimeType = mimeType != null ? mimeType : _cocoonContext.getMimeType(fileName.toLowerCase());
            
            resource.setMimeType(finalMimeType != null ? finalMimeType : "application/unknown");
            resource.setInputStream(is);
        }
        
        // store the file usage, so that it won't be deleted immediately
        _usedLocalFiles.add(fileName);
        
        return fileName;
    }
    
    /**
     * Process a local file.
     * @param attrs the img tag attributes.
     * @return the new img tag attributes.
     */
    protected Attributes _processLocal(Attributes attrs)
    {
        // src contains the fileName
        String filename = attrs.getValue("data-ametys-src");
        _usedLocalFiles.add(filename);
        
        AttributesImpl newAttrs = new AttributesImpl(attrs);
        if (!"marker".equals(attrs.getValue("marker")))
        {
            if (_richText instanceof RichText)
            {
                NamedResource file = ((RichText) _richText).getAttachment(filename);
                if (file != null)
                {
                    try (InputStream is = file.getInputStream())
                    {
                        _addDimensionAttributes(is, newAttrs);
                    }
                    catch (IOException e)
                    {
                        // Ignore
                    }
                }
            }
            else
            {
                File file = ((ModifiableRichText) _richText).getAdditionalDataFolder().getFile(filename);
                try (InputStream is = file.getResource().getInputStream())
                {
                    _addDimensionAttributes(is, newAttrs);
                }
                catch (IOException e)
                {
                    // Ignore
                }
            }
        }
        
        return newAttrs;
    }

    /**
     * Process a resource.
     * @param attrs the img tag attributes.
     * @return the new img tag attributes.
     */
    protected Attributes _processResource(Attributes attrs)
    {
        String ametys_src = attrs.getValue("data-ametys-src");
        
        Resource resource = null;
        try
        {
            resource = _ametysResolver.resolveById(ametys_src);
        }
        catch (UnknownAmetysObjectException ex)
        {
            getLogger().warn("Link to unexisting resource image " + ametys_src, ex);
            return attrs;
        }
        
        AttributesImpl newAttrs = new AttributesImpl(attrs);
        if (!"marker".equals(attrs.getValue("marker")))
        {
            try (InputStream is = resource.getInputStream())
            {
                _addDimensionAttributes(is, newAttrs);
            }
            catch (IOException e)
            {
                // Ignore
            }
        }
        
        return newAttrs;
    }

    /**
     * Add an image's width and height to the XML attributes.
     * @param inputStream an input stream on the image.
     * @param attrs the attributes to fill.
     * @throws IOException if an error occurs during reading dimension
     */
    protected void _addDimensionAttributes(InputStream inputStream, AttributesImpl attrs) throws IOException
    {
        // We need to call Thumbnail to get image dimension with EXIF orientation tag
        BufferedImage img = ImageHelper.read(inputStream);
        if (img != null && attrs.getValue("width") == null)
        {
            attrs.addCDATAAttribute("width", Integer.toString(img.getWidth()));
        }
        if (img != null && attrs.getValue("height") == null)
        {
            attrs.addCDATAAttribute("height", Integer.toString(img.getHeight()));
        }
    }
        
    @Override
    public void endElement(String uri, String loc, String raw) throws SAXException
    {
        if ("img".equals(raw) && _tagToIgnore)
        {
            // ignore img tag
            _tagToIgnore = false;
            return;
        }
        
        super.endElement(uri, loc, raw);
    }
    
    @Override
    public void endDocument() throws SAXException
    {
        if (_richText instanceof RichText)
        {
            RichText richText = (RichText) _richText;
            
            // Look for unused files
            Set<String> unusedLocalFiles = richText.getAttachmentNames()
                                                    .stream()
                                                    .filter(fileName -> !_usedLocalFiles.contains(fileName))
                                                    .collect(Collectors.toSet());
            // Remove unused files        
            unusedLocalFiles.stream()
                            .forEach(richText::removeAttachment);
        }
        else
        {
            ModifiableRichText richText = (ModifiableRichText) _richText;

            // removing unused files
            ModifiableFolder folder = richText.getAdditionalDataFolder();
            for (File file : folder.getFiles())
            {
                String fileName = file.getName();
                
                if (!_usedLocalFiles.contains(fileName))
                {
                    folder.remove(fileName);
                }
            }
        }
        
        super.endDocument();
    }
}