/*
 *  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.List;
import java.util.Map;
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 String __RICH_TEXT_MIME_TYPE = "text/xml";
    private static final String __RICH_TEXT_ENCODING = "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> _attachments = new HashMap<>();
    
    /** the files contained in the rich text */
    protected Map<String, NamedResource> _addedAttachments = 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 String getMimeType()
    {
        return __RICH_TEXT_MIME_TYPE;
    }
    
    @Override
    public void setMimeType(String mimeType)
    {
        if (__RICH_TEXT_MIME_TYPE.equals(mimeType))
        {
            super.setMimeType(mimeType);
        }
        else
        {
            throw new IllegalArgumentException("The mime type '" + mimeType + "' is not authorized for rich texts. The only authorized mime type is '" + __RICH_TEXT_MIME_TYPE + "'.");
        }
    }
    
    @Override
    public String getEncoding()
    {
        return __RICH_TEXT_ENCODING;
    }
    
    @Override
    public void setEncoding(String encoding)
    {
        if (__RICH_TEXT_ENCODING.equals(encoding))
        {
            super.setEncoding(encoding);
        }
        else
        {
            throw new IllegalArgumentException("The encoding '" + encoding + "' is not authorized for rich texts. The only authorized encoding is '" + __RICH_TEXT_ENCODING + "'.");
        }
    }

    /**
     * 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()
    {
        if (_folderData != null)
        {
            return _folderData.getDataNames(StringUtils.EMPTY).stream()
                                                              .map(Text::unescapeIllegalJcrChars)
                                                              .collect(Collectors.toSet());
        }
        else
        {
            return _attachments.keySet();
        }
    }
    
    /**
     * Retrieves the rich text's attachments
     * @return the rich text's attachments
     */
    public Collection<NamedResource> getAttachments()
    {
        if (_folderData != null)
        {
            return _getAttachmentsFromFolderData();
        }
        else
        {
            return _attachments.values();
        }
    }
    
    private List<NamedResource> _getAttachmentsFromFolderData()
    {
        List<NamedResource> attachments = new ArrayList<>();
        
        for (String escapedFileName : _folderData.getDataNames(StringUtils.EMPTY))
        {
            NamedResource file = _getAttachmentFromFolderData(Text.unescapeIllegalJcrChars(escapedFileName));
            
            attachments.add(file);
        }
        
        return attachments;
    }
    
    /**
     * Retrieves the attachments that have been added to the rich text  
     * @return the added attachments
     */
    public Collection<NamedResource> getAddedAttachments()
    {
        return _addedAttachments.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)
    {
        if (_folderData != null)
        {
            return _folderData.hasValue(Text.escapeIllegalJcrChars(filename), StringUtils.EMPTY);
        }
        else
        {
            return _attachments.containsKey(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)
    {
        if (_folderData != null)
        {
            return _getAttachmentFromFolderData(filename);
        }
        else
        {
            return _attachments.get(filename);
        }
    }

    private NamedResource _getAttachmentFromFolderData(String filename)
    {
        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);
        
        return attachment;
    }
    
    /**
     * Adds an attachment to the rich text
     * @param attachment the attachment to add
     */
    public void addAttachment(NamedResource attachment)
    {
        String filename = attachment.getFilename();
        
        _addedAttachments.put(filename, attachment);
        _attachments.put(filename, attachment);
        
        if (_removedAttachments.contains(filename))
        {
            _removedAttachments.remove(filename);
        }
        
        _folderData = null;
    }

    /**
     * Remove an attachment from the rich text
     * @param filename the name of the attachment to remove
     */
    public void removeAttachment(String filename)
    {
        if (_attachments.containsKey(filename))
        {
            _removedAttachments.add(filename);
            _attachments.remove(filename);
        
            if (_addedAttachments.containsKey(filename))
            {
                _addedAttachments.remove(filename);
            }
            
            _folderData = null;
        }
    }

    /**
     * Remove all the attachments from the rich text
     */
    public void removeAttachments()
    {
        _removedAttachments.addAll(_attachments.keySet());
        _attachments = new HashMap<>();
        _addedAttachments = new HashMap<>();
        _folderData = null;
    }
}