/*
 *  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.web.repository.page.jcr;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Set;

import javax.jcr.ItemExistsException;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Value;

import org.apache.commons.collections4.MapUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.tag.jcr.TaggableAmetysObjectHelper;
import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.explorer.resources.jcr.JCRResourcesCollectionFactory;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectIterator;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CollectionIterable;
import org.ametys.plugins.repository.CopiableAmetysObject;
import org.ametys.plugins.repository.ModifiableTraversableAmetysObject;
import org.ametys.plugins.repository.RepositoryConstants;
import org.ametys.plugins.repository.RepositoryIntegrityViolationException;
import org.ametys.plugins.repository.TraversableAmetysObject;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.holder.ModifiableDataHolder;
import org.ametys.plugins.repository.data.holder.ModifiableModelAwareDataHolder;
import org.ametys.plugins.repository.data.holder.ModifiableModelLessDataHolder;
import org.ametys.plugins.repository.data.holder.impl.DataHolderHelper;
import org.ametys.plugins.repository.data.holder.impl.DefaultModifiableModelLessDataHolder;
import org.ametys.plugins.repository.data.repositorydata.ModifiableRepositoryData;
import org.ametys.plugins.repository.data.repositorydata.impl.JCRRepositoryData;
import org.ametys.plugins.repository.jcr.DefaultTraversableAmetysObject;
import org.ametys.plugins.repository.jcr.SimpleAmetysObject;
import org.ametys.plugins.repository.metadata.ModifiableCompositeMetadata;
import org.ametys.runtime.model.View;
import org.ametys.runtime.model.exception.BadItemTypeException;
import org.ametys.runtime.model.exception.NotUniqueTypeException;
import org.ametys.runtime.model.exception.UndefinedItemPathException;
import org.ametys.runtime.model.exception.UnknownTypeException;
import org.ametys.runtime.model.type.DataContext;
import org.ametys.runtime.model.type.ModelItemTypeConstants;
import org.ametys.web.parameters.view.ViewParametersManager;
import org.ametys.web.parameters.view.ViewParametersModel;
import org.ametys.web.repository.page.ModifiablePage;
import org.ametys.web.repository.page.ModifiableZone;
import org.ametys.web.repository.page.MoveablePage;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.PagesContainer;
import org.ametys.web.repository.page.UnknownZoneException;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;

/**
 * {@link Page} implementation stored into a JCR node using
 * <code>ametys:defaultPage</code> node type.
 * 
 * @param <F> the actual type of factory.
 */
public class DefaultPage<F extends DefaultPageFactory> extends DefaultTraversableAmetysObject<F> implements ModifiablePage, CopiableAmetysObject, MoveablePage
{
    /** Constant for title metadata. */
    public static final String METADATA_TITLE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":title";

    /** Constant for long title metadata. */
    public static final String METADATA_LONG_TITLE = "long-title";

    /** Constant for title metadata. */
    public static final String METADATA_TYPE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":type";

    /** Constant for title metadata. */
    public static final String METADATA_URL = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":url";

    /** Constant for title metadata. */
    public static final String METADATA_URLTYPE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":url-type";

    /** Constant for template metadata. */
    public static final String METADATA_TEMPLATE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":template";

    /** Constant for referers metadata. */
    public static final String METADATA_REFERERS = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":referers";
    
    /** Constant for the visible attribute. */
    public static final String METADATA_VISIBLE = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":visible";

    /** Constant for robots metadata. */
    public static final String METADATA_ROBOTS_DISALLOW = "robots-disallow";
    
    /** Constant for the zones node name. */
    public static final String ZONES_NODE_NAME = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":zones";

    /** Constant for the zones node type. */
    public static final String ZONES_NODE_TYPE = RepositoryConstants.NAMESPACE_PREFIX + ":zones";

    /** Constant for the zone node type. */
    public static final String ZONE_NODE_TYPE = RepositoryConstants.NAMESPACE_PREFIX + ":zone";
    
    /** Constant for the attachment node name. */
    public static final String ATTACHMENTS_NODE_NAME = RepositoryConstants.NAMESPACE_PREFIX_INTERNAL + ":attachments";
    
    /** Constants for site Metadata* */
    public static final String METADATA_SITE = "site";
    
    /** Constants for sitemap Metadata* */
    public static final String METADATA_SITEMAP = "sitemap";

    /** Constant for publication start date metadata. */
    public static final String METADATA_PUBLICATION_START_DATE = "publicationStartDate";
    
    /** Constant for publication end date metadata. */
    public static final String METADATA_PUBLICATION_END_DATE = "publicationEndDate";
    
    private static final Logger __LOGGER = LoggerFactory.getLogger(DefaultPage.class);
    
    /**
     * Creates a {@link DefaultPage}.
     * 
     * @param node the node backing this {@link AmetysObject}.
     * @param parentPath the parent path in the Ametys hierarchy.
     * @param factory the {@link DefaultPageFactory} which creates the
     *            AmetysObject.
     */
    public DefaultPage(Node node, String parentPath, F factory)
    {
        super(node, parentPath, factory);
    }

    @Override
    public Set<String> getTags() throws AmetysRepositoryException
    {
        return TaggableAmetysObjectHelper.getTags(this);
    }
    
    @Override
    public void tag(String tag) throws AmetysRepositoryException
    {
        TaggableAmetysObjectHelper.tag(this, tag);
    }

    @Override
    public void untag(String tag) throws AmetysRepositoryException
    {
        TaggableAmetysObjectHelper.untag(this, tag);
    }

    @Override
    public String getTitle() throws AmetysRepositoryException
    {
        try
        {
            return getNode().getProperty(METADATA_TITLE).getString();
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get title property", e);
        }
    }

    @Override
    public void setTitle(String title) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_TITLE, title);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set title property", e);
        }
    }

    @Override
    public String getLongTitle() throws AmetysRepositoryException
    {
        String longTitle = getValue(METADATA_LONG_TITLE);
        if (StringUtils.isNotBlank(longTitle))
        {
            return longTitle;
        }
        else
        {
            return this.getTitle();
        }
    }

    @Override
    public void setLongTitle(String title) throws AmetysRepositoryException
    {
        String newTitle = StringUtils.trimToNull(title);
        setValue(METADATA_LONG_TITLE, newTitle, ModelItemTypeConstants.STRING_TYPE_ID);
    }

    @Override
    public Sitemap getSitemap() throws AmetysRepositoryException
    {
        try
        {
            Node node = getNode();

            do
            {
                node = node.getParent();
            }
            while (!node.getPrimaryNodeType().getName().equals(Sitemap.NODE_TYPE));

            return _getFactory().resolveAmetysObject(node);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get sitemap", e);
        }
    }
    
    @Override
    public int getDepth() throws AmetysRepositoryException
    {
        try
        {
            int depth = 1;
            Node node = getNode().getParent();
            while (!node.getPrimaryNodeType().getName().equals(Sitemap.NODE_TYPE))
            {
                depth++;
                node = node.getParent();
            }

            return depth;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get depth", e);
        }
    }

    @Override
    public Site getSite() throws AmetysRepositoryException
    {
        return getSitemap().getSite();
    }
    
    @Override
    public String getSiteName()
    {
        return getValue(METADATA_SITE);
    }
    
    @Override
    public void setSiteName(String siteName)
    {
        setValue(METADATA_SITE, siteName);
    }
    
    @Override
    public String getSitemapName() throws AmetysRepositoryException
    {
        return getValue(METADATA_SITEMAP);
    }
    
    @Override
    public void setSitemapName(String sitemapName) throws AmetysRepositoryException
    {
        setValue(METADATA_SITEMAP, sitemapName);
    }

    @Override
    public String getPathInSitemap() throws AmetysRepositoryException
    {
        String nodePath = getPath();
        String sitemapPath = getSitemap().getPath();
        return nodePath.substring(sitemapPath.length() + 1);
    }

    @Override
    public PageType getType() throws AmetysRepositoryException
    {
        try
        {
            return PageType.valueOf(getNode().getProperty(METADATA_TYPE).getString());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get type property", e);
        }
    }

    @Override
    public void setType(PageType type) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_TYPE, type.name());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set type property", e);
        }
    }

    @Override
    public String getURL() throws AmetysRepositoryException
    {
        try
        {
            return getNode().getProperty(METADATA_URL).getString();
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get url property", e);
        }
    }
    
    @Override
    public LinkType getURLType() throws AmetysRepositoryException
    {
        try
        {
            return LinkType.valueOf(getNode().getProperty(METADATA_URLTYPE).getString());
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get url type property", e);
        }
    }

    @Override
    public void setURL(LinkType type, String url) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_URLTYPE, type.toString());
            getNode().setProperty(METADATA_URL, url);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set url property", e);
        }
    }

    @Override
    public String getTemplate() throws AmetysRepositoryException
    {
        try
        {
            Node node = getNode();
            
            if (node.hasProperty(METADATA_TEMPLATE))
            {
                return node.getProperty(METADATA_TEMPLATE).getString();
            }
            else
            {
                return null;
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get template property", e);
        }
    }

    @Override
    public void setTemplate(String template) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_TEMPLATE, template);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set template property", e);
        }
    }

    @Override
    public AmetysObjectIterable<ModifiableZone> getZones() throws AmetysRepositoryException
    {
        try
        {
            return ((TraversableAmetysObject) getChild(ZONES_NODE_NAME)).getChildren();
        }
        catch (UnknownAmetysObjectException e)
        {
            Collection<ModifiableZone> emptyCollection = Collections.emptyList();
            return new CollectionIterable<>(emptyCollection);
        }
    }

    @Override
    public boolean hasZone(String name) throws AmetysRepositoryException
    {
        if (hasChild(ZONES_NODE_NAME))
        {
            return ((TraversableAmetysObject) getChild(ZONES_NODE_NAME)).hasChild(name);
        }
        else
        {
            return false;
        }
    }
    
    @Override
    public ModifiableZone getZone(String name) throws UnknownZoneException, AmetysRepositoryException
    {
        return ((TraversableAmetysObject) getChild(ZONES_NODE_NAME)).getChild(name);
    }

    @Override
    public ModifiableZone createZone(String name) throws AmetysRepositoryException
    {
        ModifiableTraversableAmetysObject zones;
        if (hasChild(ZONES_NODE_NAME))
        {
            zones = getChild(ZONES_NODE_NAME);
        }
        else
        {
            zones = createChild(ZONES_NODE_NAME, ZONES_NODE_TYPE);
        }
        
        return zones.createChild(name, ZONE_NODE_TYPE); 
    }

    @Override
    public ResourceCollection getRootAttachments() throws AmetysRepositoryException
    {
        ResourceCollection attachments;
        if (hasChild(ATTACHMENTS_NODE_NAME))
        {
            attachments = getChild(ATTACHMENTS_NODE_NAME);
        }
        else
        {
            attachments = createChild(ATTACHMENTS_NODE_NAME, JCRResourcesCollectionFactory.RESOURCESCOLLECTION_NODETYPE);
            
            try
            {
                getNode().getSession().save();
            }
            catch (RepositoryException e)
            {
                throw new AmetysRepositoryException("Unable to save session", e);
            }
        }
        
        return attachments;
    }
    
    @Override
    public Set<String> getReferers() throws AmetysRepositoryException
    {
        try
        {
            Node node = getNode();

            if (!node.hasProperty(METADATA_REFERERS))
            {
                return Collections.emptySet();
            }

            Value[] values = getNode().getProperty(METADATA_REFERERS).getValues();
            Set<String> ids = new HashSet<>(values.length);

            for (Value value : values)
            {
                ids.add(value.getString());
            }

            return ids;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get referers property", e);
        }
    }

    @Override
    public void addReferer(String ametysObjectId) throws AmetysRepositoryException
    {
        try
        {
            Set<String> ids = null;
            Node node = getNode();

            if (!node.hasProperty(METADATA_REFERERS))
            {
                ids = Collections.singleton(ametysObjectId);
            }
            else
            {
                Value[] values = getNode().getProperty(METADATA_REFERERS).getValues();
                ids = new HashSet<>(values.length + 1);

                for (Value value : values)
                {
                    ids.add(value.getString());
                }

                ids.add(ametysObjectId);
            }

            node.setProperty(METADATA_REFERERS, ids.toArray(new String[ids.size()]));
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to add an id into referers property", e);
        }
    }

    @Override
    public void removeReferer(String ametysObjectId) throws AmetysRepositoryException
    {
        try
        {
            Node node = getNode();

            if (node.hasProperty(METADATA_REFERERS))
            {
                Value[] values = getNode().getProperty(METADATA_REFERERS).getValues();
                Set<String> ids = new HashSet<>(values.length + 1);

                for (Value value : values)
                {
                    ids.add(value.getString());
                }

                ids.remove(ametysObjectId);
                node.setProperty(METADATA_REFERERS, ids.toArray(new String[ids.size()]));
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to remove an id from referers property", e);
        }
    }

    @Override
    public AmetysObjectIterable< ? extends Page> getChildrenPages() throws AmetysRepositoryException
    {
        return getChildrenPages(true);
    }
    
    @Override
    public AmetysObjectIterable< ? extends Page> getChildrenPages(boolean includeInvisiblePage) throws AmetysRepositoryException
    {
        List<Page> childrenPages = new ArrayList<>();
        for (AmetysObject childObject : getChildren())
        {
            if (childObject instanceof Page)
            {
                Page page = (Page) childObject;
                if (includeInvisiblePage || page.isVisible())
                {
                    childrenPages.add(page);
                }
            }
        }
        return new CollectionIterable<>(childrenPages);
    }
    
    @Override
    public Page getChildPageAt(int index) throws UnknownAmetysObjectException, AmetysRepositoryException
    {
        if (index < 0)
        {
            throw new AmetysRepositoryException("Child page index cannot be negative");
        }
        
        AmetysObjectIterable< ? extends Page> childPages = getChildrenPages();
        AmetysObjectIterator< ? extends Page> it = childPages.iterator();
        
        try
        {
            it.skip(index);
            return it.next();
        }
        catch (NoSuchElementException e)
        {
            throw new UnknownAmetysObjectException("There's no child page at index " + index + " for page " + this.getId());
        }
    }

    @Override
    public DefaultPage copyTo(ModifiableTraversableAmetysObject parent, String name, List<String> restrictTo) throws AmetysRepositoryException
    {
        try
        {
            int index = 1;
            String originalName = name == null ? getName() : name;
            String pageName = originalName;
            while (parent.hasChild(pageName))
            {
                // Find unused name on new parent node
                pageName = originalName + "-" + index++;
            }
            
            DefaultPage cPage = parent.createChild(pageName, "ametys:defaultPage");
            cPage.setType(getType());
            cPage.setTitle(getTitle());
            
            if (PageType.CONTAINER.equals(getType()))
            {
                cPage.setTemplate(getTemplate());
            }
            else if (PageType.LINK.equals(getType()))
            {
                cPage.setURL(getURLType(), getURL());
            }
            
            // Copy metadata
            copyTo(cPage);
            
            // Copy view parameters
            getTemplateParametersHolder().copyTo(cPage.getTemplateParametersHolder());
            
            // Copy zones
            for (ModifiableZone zone : getZones())
            {
                if (zone instanceof CopiableAmetysObject)
                {
                    ((CopiableAmetysObject) zone).copyTo(cPage, null);
                }
            }
            
            // Copy tags
            Set<String> tags = getTags();
            for (String tag : tags)
            {
                cPage.tag(tag);
            }
            
            // Update sitemap name
            if (parent instanceof PagesContainer)
            {
                cPage.setSitemapName(((PagesContainer) parent).getSitemapName());
            }
            
            parent.saveChanges();
            
            // Copy attachments
            ResourceCollection rootAttachments = getRootAttachments();
            if (rootAttachments instanceof SimpleAmetysObject)
            {
                Node resourcesNode = ((SimpleAmetysObject) rootAttachments).getNode();
                getNode().getSession().getWorkspace().copy(resourcesNode.getPath(), cPage.getNode().getPath() + "/" + resourcesNode.getName());
            }
            
            // Copy sub-pages
            AmetysObjectIterable< ? extends Page> childrenPages = getChildrenPages();
            for (Page page : childrenPages)
            {
                // Avoid infinite loop : do not copy the page itself
                if (page instanceof CopiableAmetysObject && restrictTo.contains(page.getId()))
                {
                    ((CopiableAmetysObject) page).copyTo(cPage, null, restrictTo);
                }
            }
            
            return cPage;
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(e);
        }
    }
    
    @Override
    public DefaultPage copyTo(ModifiableTraversableAmetysObject parent, String name) throws AmetysRepositoryException
    {
        return copyTo (parent, name, new ArrayList<String>());
    }
    
    public void copyTo(ModifiableDataHolder dataHolder) throws UndefinedItemPathException, BadItemTypeException, UnknownTypeException, NotUniqueTypeException
    {
        for (String name : getDataNames())
        {
            if (!ViewParametersManager.VIEW_PARAMETERS_COMPOSITE_NAME.equals(name))
            {
                DataHolderHelper.copyTo(getDataHolder(), dataHolder, name);
            }
        }
    }
    
    @Override
    public void moveTo(AmetysObject newParent, boolean renameIfExist) throws AmetysRepositoryException, RepositoryIntegrityViolationException
    {
        Node node = getNode();

        try
        {
            if (getParent().equals(newParent))
            {
                // Just order current node to the end
                node.getParent().orderBefore(node.getName(), null);
            }
            else
            {
                if (!canMoveTo(newParent))
                {
                    throw new AmetysRepositoryException("DefaultPage " + toString() + " can only be moved to a CompositePages and ");
                }
                PagesContainer newParentPage = (PagesContainer) newParent;
                
                String sitemapNodePath = getSitemap().getNode().getPath();
                String newPath = sitemapNodePath + (newParentPage instanceof Sitemap ? "" : '/' + newParentPage.getPathInSitemap());

                String name = node.getName();
                
                if (renameIfExist)
                {
                    // Find unused name on new parent node
                    int index = 1;
                    while (node.getSession().getRootNode().hasNode(newPath.substring(1) + "/" + name))
                    {
                        name = name + "-" + index++;
                    }
                }

                try
                {
                    // Move node
                    node.getSession().move(node.getPath(), newPath + "/" + name);
                }
                catch (ItemExistsException e)
                {
                    throw new AmetysRepositoryException(String.format("A page already exists for in parent path '%s'", newPath), e);
                }
                
                // recompute name in case it has changed
                _invalidateName();

                // Invalidate parent path as the parent path has changed
                _invalidateParentPath();
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(String.format("Unable to move page '%s' to node '%s'", this, newParent.getId()), e);
        }
    }
    
    @Override
    public boolean canMoveTo(AmetysObject newParent) throws AmetysRepositoryException
    {
        return  newParent instanceof PagesContainer && ((PagesContainer) newParent).getSitemap().equals(getSitemap());
    }

    @Override
    public void orderBefore(AmetysObject siblingNode) throws AmetysRepositoryException
    {
        Node node = getNode();
        try
        {
            node.getParent().orderBefore(node.getName(), siblingNode != null ? siblingNode.getName() : null);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException(String.format("Unable to order page '%s' before sibling '%s'", this, siblingNode != null ? siblingNode.getName() : ""), e);
        }
    }

    @Override
    public boolean isVisible() throws AmetysRepositoryException
    {
        try
        {
            if (getNode().hasProperty(METADATA_VISIBLE))
            {
                return getNode().getProperty(METADATA_VISIBLE).getBoolean();
            }
            else
            {
                return true;
            }
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to get visible property", e);
        }
    }
    
    @Override
    public void setVisible(boolean isVisible) throws AmetysRepositoryException
    {
        try
        {
            getNode().setProperty(METADATA_VISIBLE, isVisible);
        }
        catch (RepositoryException e)
        {
            throw new AmetysRepositoryException("Unable to set visible property", e);
        }
    }

    public ModifiableModelLessDataHolder getDataHolder()
    {
        ModifiableRepositoryData repositoryData = new JCRRepositoryData(getNode());
        return new DefaultModifiableModelLessDataHolder(_getFactory().getPageDataTypeExtensionPoint(), repositoryData);
    }
    
    @Override
    public ModifiableCompositeMetadata getMetadataHolder()
    {
        __LOGGER.warn("The getMetadataHolder method of DefaultPage is deprecated. Use the getDataHolder instead. StackTrace: ", new Exception());
        return super.getMetadataHolder();
    }
    
    public ModifiableModelAwareDataHolder getTemplateParametersHolder() throws AmetysRepositoryException
    {
        JCRRepositoryData zoneItemRepositoryData = new JCRRepositoryData(getNode());
        
        // Get the template Id
        String templateId = getTemplate();
        
        // Get the skin Id
        String skinId = getSite().getSkinId();
        
        ViewParametersManager viewParametersManager = _getFactory().getViewParametersManager();
        Optional<ViewParametersModel> templateViewParameters = viewParametersManager.getTemplateViewParametersModel(skinId, templateId);
        if (templateViewParameters.isEmpty())
        {
            templateViewParameters = Optional.of(new ViewParametersModel("template-no-param", new View(), MapUtils.EMPTY_SORTED_MAP));
        }
        
        return viewParametersManager.getParametersHolder(zoneItemRepositoryData, templateViewParameters.get());
    }
    
    /*
     * The default implementation is overridden here to not use the getDataHolder()#dataToSAX implementation
     * Each #dataToSAX method calls the next one and the implementation that has to change is the last one.
     * If the getDataHolder() is used for one, the next ones will be called with the default implementation
     */
    public void dataToSAX(ContentHandler contentHandler, DataContext context) throws SAXException, IOException, UnknownTypeException, NotUniqueTypeException
    {
        for (String name : getDataNames())
        {
            dataToSAX(contentHandler, name, context);
        }
    }
    
    public void dataToSAX(ContentHandler contentHandler, String dataPath, DataContext context) throws SAXException, IOException
    {
        if (!ViewParametersManager.VIEW_PARAMETERS_COMPOSITE_NAME.equals(dataPath))
        {
            ModifiablePage.super.dataToSAX(contentHandler, dataPath, context);
        }
    }
}