/*
 *  Copyright 2013 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.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.cocoon.components.ContextHelper;
import org.apache.cocoon.environment.ObjectModelHelper;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;

import org.ametys.cms.data.RichText;

/**
 * This transformer extracts semantic annotation from the incoming HTML for further processing.
 * Appends all text nodes inside <span annotation="xxx"< element.
 */
public class SemanticAnnotationsEditionHandler extends AbstractHTMLEditionHandler
{
    private static final String __ANNOTATION_TAG_NAME = "span";
    private static final String __ANNOTATION_ATTRIBUTE = "annotation";
    
    SemanticAnnotationsHolder _annotationsHolder;
    
    /**
     * When document starts, a holder of semanticAnnotations is created
     * @see org.ametys.cms.transformation.htmledition.AbstractHTMLEditionHandler#startDocument()
     */
    @Override
    public void startDocument() throws SAXException
    {
        Map objectModel = ContextHelper.getObjectModel(_context);
        Map parentContextParameters = (Map) objectModel.get(ObjectModelHelper.PARENT_CONTEXT);
        RichText richText = (RichText) parentContextParameters.get("richText");
        
        if (richText != null)
        {
            // Remove all existing annotations from the rich text node.
            richText.removeAllAnnotations();
            // Create a holder to write the annotations to.
            _annotationsHolder = new SemanticAnnotationsHolder(richText);
        }
        
        super.startDocument();
    }
        
    /**
     * Dispatch the startElement event to semanticAnnotations. Add a new annotation in the holder if the element matches a semantic annotation element
     * @see org.ametys.cms.transformation.htmledition.AbstractHTMLEditionHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
     */
    @Override
    public void startElement(String uri, String loc, String raw, Attributes attrs) throws SAXException
    {                
        if (_annotationsHolder != null)
        {
            // Existing semantic annotations continue being saxed
            _annotationsHolder.startElement();
            
            // A new semantic annotation starts being saxed
            if (__ANNOTATION_TAG_NAME.equals(loc) && attrs.getValue(__ANNOTATION_ATTRIBUTE) != null) 
            {
                // We will now track its annotationValue through the SAX events
                _annotationsHolder.newSaxedSemanticAnnotation(attrs.getValue(__ANNOTATION_ATTRIBUTE));
            }
        }
        super.startElement(uri, loc, raw, attrs);
    }
        
    /**
     * Dispatch the characters event to semanticAnnotations.
     * @see org.ametys.cms.transformation.htmledition.AbstractHTMLEditionHandler#characters(char[], int, int)
     */
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException
    {
        if (_annotationsHolder != null)
        {
            _annotationsHolder.characters(ch, start, length);
        }
        
        super.characters(ch, start, length);
    }
    
    /**
     * Dispatch the endElement event to semanticAnnotations.
     * @see org.ametys.cms.transformation.htmledition.AbstractHTMLEditionHandler#characters(char[], int, int)
     */
    @Override
    public void endElement(String uri, String loc, String raw) throws SAXException
    {    
        if (_annotationsHolder != null)
        {
            _annotationsHolder.endElement();
        }
                
        super.endElement(uri, loc, raw);
    }
    
    /**
     * A placeholder for saxedSemanticAnnotations
     * Maintains a list of the saxedSemanticAnnotations.
     * Dispatch SAX events to each saxedSemanticAnnotation.
     */
    private class SemanticAnnotationsHolder
    {
        protected List<AbstractSaxedSemanticAnnotation> _saxedSemanticAnnotations = new ArrayList<>();
        RichText _richText;
        
        public SemanticAnnotationsHolder(RichText richText)
        {
            _richText = richText;
        }
        
        public void startElement() 
        {
            for (AbstractSaxedSemanticAnnotation saxedSemanticAnnotation : _saxedSemanticAnnotations)
            {
                saxedSemanticAnnotation.startElement();
            }
        }
        
        public void endElement() throws SAXException
        {
            for (Iterator<AbstractSaxedSemanticAnnotation> it = _saxedSemanticAnnotations.iterator(); it.hasNext();)
            {
                AbstractSaxedSemanticAnnotation saxedSemanticAnnotation = it.next();
                try
                {
                    saxedSemanticAnnotation.endElement();
                    // Delete (finished) saxedSemanticAnnotation
                    if (saxedSemanticAnnotation.hasFinished())
                    {
                        it.remove();
                    }
                }
                catch (Exception e)
                {
                    String annotationName = saxedSemanticAnnotation.getCurrentAnnotationName();
                    throw new SAXException("Unable to save semantic annotation " + annotationName + " in repository", e);
                }
            }
        }
        
        public void characters(char[] ch, int start, int length)
        {
            for (AbstractSaxedSemanticAnnotation saxedSemanticAnnotation : _saxedSemanticAnnotations)
            {
                saxedSemanticAnnotation.characters(ch, start, length);
            }
        }
        
        /**
         * Add a new semantic annotation in the holder 
         * @param annotationName The name of the semantic annotation
         */
        public void newSaxedSemanticAnnotation(String annotationName)
        {
            if (_richText != null)
            {
                AbstractSaxedSemanticAnnotation saxedSemanticAnnotation = new AbstractSaxedSemanticAnnotation(annotationName)
                {
                    /**
                     * A SaxedSemanticAnnotation  persists itself to JCR on its endElement.
                     * @see org.ametys.cms.transformation.htmledition.SemanticAnnotationsEditionHandler.AbstractSaxedSemanticAnnotation#onAnnotationReady()
                     */
                    @Override
                    public void onAnnotationReady() throws Exception
                    {
                        // When the semAnnotation is fully saxed, persist it to JCR
                        _richText.addAnnotations(getCurrentAnnotationName(), getCurrentAnnotationValue().toString());
                    }
                };
                
                _saxedSemanticAnnotations.add(saxedSemanticAnnotation);
            }
        }
    }
    
    /**
     * A semantic annotation defined through a serie of SAX events.
     * The abstract onAnnotationReady() method takes care of the annotation as soon as it is fully SAXed.  
     */
    private abstract class AbstractSaxedSemanticAnnotation
    {
        private final String _currentAnnotationName;
        private int _cptrElementsInsideSemanticAnnotation;
        private final StringBuilder _currentAnnotationValue;
        private boolean _hasFinished;
        
        public AbstractSaxedSemanticAnnotation(String annotationName)
        {
            this._currentAnnotationName = annotationName;
            this._cptrElementsInsideSemanticAnnotation = 0;
            this._currentAnnotationValue = new StringBuilder();
            this._hasFinished = false;
        }
        
        public void startElement() 
        {
            _cptrElementsInsideSemanticAnnotation++;
        }
        
        public void endElement() throws Exception
        {
            if (_cptrElementsInsideSemanticAnnotation == 0)
            {                
                onAnnotationReady();
                _hasFinished = true;
            }
            else 
            {
                _cptrElementsInsideSemanticAnnotation--;                
            }            
        }
        
        public abstract void onAnnotationReady() throws Exception;

        public void characters(char[] ch, int start, int length)
        {
            _currentAnnotationValue.append(ch, start, length);
        }

        public String getCurrentAnnotationName()
        {
            return _currentAnnotationName;
        }


        public StringBuilder getCurrentAnnotationValue()
        {
            return _currentAnnotationValue;
        }


        public boolean hasFinished()
        {
            return _hasFinished;
        }
    }
}