/*
 *  Copyright 2019 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.data;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;
import org.apache.jackrabbit.util.Text;

import org.ametys.cms.data.type.ResourceElementTypeHelper;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.data.repositorydata.RepositoryData;

/**
 * CLass representing a rich text
 */
public class RichText extends Resource
{
    private static final String __ATTACHMENT_CONTENT_IDENTIFIER = "content";
    
    private static final Set<String> __AVAILABLE_MIME_TYPES_FOR_RICH_TEXT;
    private static final Set<String> __AVAILABLE_ENCODINGS_FOR_RICH_TEXT;
    
    static
    {
        __AVAILABLE_MIME_TYPES_FOR_RICH_TEXT = new HashSet<>();
        __AVAILABLE_MIME_TYPES_FOR_RICH_TEXT.add("text/xml");
        __AVAILABLE_MIME_TYPES_FOR_RICH_TEXT.add("application/xml");
        __AVAILABLE_MIME_TYPES_FOR_RICH_TEXT.add("text/plain");
        
        __AVAILABLE_ENCODINGS_FOR_RICH_TEXT = new HashSet<>();
        __AVAILABLE_ENCODINGS_FOR_RICH_TEXT.add("UTF-8");
    }
    
    /** the rich text's annotations */
    protected Map<String, List<String>> _annotations = new HashMap<>();
    
    /** The resource's repository data */
    protected RepositoryData _folderData;
    
    /** the files contained in the rich text */
    protected Map<String, NamedResource> _fetchedAttachments = new HashMap<>();
    
    /** the files contained in the rich text */
    protected Collection<String> _removedAttachments = new ArrayList<>();
    
    /**
     * Default constructor
     */
    public RichText()
    {
        // Empty contructor
    }
    
    /**
     * Constructor to use when reading the rich text from the repository
     * @param richTextData the repository data containing the rich text's data
     * @param folderData the repository data containing the folder's data
     */
    public RichText(RepositoryData richTextData, RepositoryData folderData)
    {
        super(richTextData);
        _folderData = folderData;
    }
    
    @Override
    public void setMimeType(String mimeType)
    {
        if (__AVAILABLE_MIME_TYPES_FOR_RICH_TEXT.stream().anyMatch(availableMimeType -> availableMimeType.equalsIgnoreCase(mimeType)))
        {
            super.setMimeType(mimeType);
        }
        else
        {
            String availableMimeTypes = StringUtils.join(__AVAILABLE_MIME_TYPES_FOR_RICH_TEXT, ", ");
            throw new IllegalArgumentException("The mime type '" + mimeType + "' is not available for rich texts. Available mime types are: '" + availableMimeTypes + "'.");
        }
    }
    
    @Override
    public void setEncoding(String encoding)
    {
        if (__AVAILABLE_ENCODINGS_FOR_RICH_TEXT.stream().anyMatch(availableEncoding -> availableEncoding.equalsIgnoreCase(encoding)))
        {
            super.setEncoding(encoding);
        }
        else
        {
            String availableEncodings = StringUtils.join(__AVAILABLE_ENCODINGS_FOR_RICH_TEXT, ", ");
            throw new IllegalArgumentException("The encoding '" + encoding + "' is not available for rich texts. Available encodings are: '" + availableEncodings + "'.");
        }
    }

    /**
     * Retrieves the rich text's annotations
     * @return the rich text's annotations
     */
    public Map<String, List<String>> getAllAnnotations()
    {
        return _annotations;
    }

    /**
     * Retrieves the rich text's annotations of the given name
     * @param name the name of the annotations to retrieve
     * @return the rich text's annotations of the given name
     */
    public List<String> getAnnotations(String name)
    {
        return _annotations.containsKey(name) ? _annotations.get(name) : new ArrayList<>();
    }

    /**
     * Add annotations to the rich text
     * @param name the name of the annotations to add
     * @param values annotations to add
     */
    public void addAnnotations(String name, String... values)
    {
        List<String> allValues = new ArrayList<>();
        if (_annotations.containsKey(name))
        {
            allValues.addAll(_annotations.get(name));
        }
        
        allValues.addAll(Arrays.asList(values));
        _annotations.put(name, allValues);
    }

    /**
     * Removes all rich text's annotations
     */
    public void removeAllAnnotations()
    {
        _annotations = new HashMap<>();
    }

    /**
     * Removes the rich text's annotations of the given name
     * @param name the name of the annotations to remove
     */
    public void removeAnnotations(String name)
    {
        _annotations.remove(name);
    }
    
    /**
     * Retrieves the names of the rich text's attachments
     * @return the names of the rich text's attachments
     */
    public Collection<String> getAttachmentNames()
    {
        Collection<String> attachnmentNames = new HashSet<>();
        attachnmentNames.addAll(_fetchedAttachments.keySet());
        
        if (_folderData != null)
        {
            attachnmentNames.addAll(_folderData.getDataNames(StringUtils.EMPTY).stream()
                    .map(Text::unescapeIllegalJcrChars)
                    .filter(name -> !_fetchedAttachments.containsKey(name))
                    .filter(name -> !_removedAttachments.contains(name))
                    .collect(Collectors.toSet()));
        }
        
        return attachnmentNames;
    }
    
    /**
     * Retrieves the rich text's attachments
     * @return the rich text's attachments
     */
    public Collection<NamedResource> getAttachments()
    {
        _fetchAttachments();
        return _fetchedAttachments.values();
    }
    
    private void _fetchAttachments()
    {
        for (String filename : getAttachmentNames())
        {
            _fetchAttachment(filename);
        }
    }
    
    /**
     * Retrieves the attachments that have already been fetched  
     * @return the fetched attachments
     */
    public Collection<NamedResource> getFetchedAttachments()
    {
        return _fetchedAttachments.values();
    }
    
    /**
     * Retrieves the names of the removed attachments of the rich text
     * @return the names of the removed attachments
     */
    public Collection<String> getRemovedAttachments()
    {
        return _removedAttachments;
    }
    
    /**
     * Checks if the rich text has an attachment with the given name
     * @param filename the name of the attachment
     * @return <code>true</code> if the rich text has an attachment with the given name, <code>false</code> otherwise
     */
    public boolean hasAttachment(String filename)
    {
        return getAttachmentNames().contains(filename);
    }

    /**
     * Retrieves the rich text's attachment with the given name, or <code>null</code> if there is no such attachment
     * @param filename the name of the attachment to retrieve
     * @return the rich text's attachment with the given name
     */
    public NamedResource getAttachment(String filename)
    {
        _fetchAttachment(filename);
        return _fetchedAttachments.get(filename);
    }
    
    private void _fetchAttachment(String filename)
    {
        if (!_fetchedAttachments.containsKey(filename) && _folderData != null)
        {
            String escapedFilename = Text.escapeIllegalJcrChars(filename);
            RepositoryData attachmentData = ResourceElementTypeHelper.getRepositoryData(_folderData, RepositoryConstants.FILE_NODETYPE, escapedFilename, StringUtils.EMPTY);
            RepositoryData resourceData = ResourceElementTypeHelper.getRepositoryData(attachmentData, RepositoryConstants.RESOURCE_NODETYPE, __ATTACHMENT_CONTENT_IDENTIFIER, ResourceElementTypeHelper.METADATA_PREFIX);
            
            NamedResource attachment = new NamedResource(resourceData);
            ResourceElementTypeHelper.readResourceData(resourceData, attachment);
            attachment.setFilename(filename);
            
            _fetchedAttachments.put(filename, attachment);
        }
    }
    
    /**
     * Adds an attachment to the rich text
     * @param attachment the attachment to add
     */
    public void addAttachment(NamedResource attachment)
    {
        String filename = attachment.getFilename();
        
        _fetchedAttachments.put(filename, attachment);
        
        if (_removedAttachments.contains(filename))
        {
            _removedAttachments.remove(filename);
        }
    }

    /**
     * Remove an attachment from the rich text
     * @param filename the name of the attachment to remove
     */
    public void removeAttachment(String filename)
    {
        _removedAttachments.add(filename);
        _fetchedAttachments.remove(filename);
    }
    
    /**
     * Remove all the attachments from the rich text
     */
    public void removeAttachments()
    {
        _removedAttachments.addAll(getAttachmentNames());
        _fetchedAttachments = new HashMap<>();
    }
}