/*
 *  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.plugins.odfweb.repository;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.FilterNameHelper;
import org.ametys.odf.program.Program;
import org.ametys.plugins.explorer.resources.ResourceCollection;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysObjectIterator;
import org.ametys.plugins.repository.AmetysObjectResolver;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CollectionIterable;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.metadata.CompositeMetadata;
import org.ametys.web.repository.page.Page;
import org.ametys.web.repository.page.UnknownZoneException;
import org.ametys.web.repository.page.Zone;
import org.ametys.web.repository.site.Site;
import org.ametys.web.repository.sitemap.Sitemap;

import com.google.common.collect.Iterables;

/**
 * Page representing a second-level page.
 */
public class SecondLevelPage implements Page
{
    private AmetysObjectResolver _resolver;
    private ODFPageCache _odfPageCache;
    private Page _root;
    private String _name;
    private String _title;
    private String _level1;
    private OdfPageHandler _odfPageHandler;
    private FirstLevelPage _level1Page;
    
    /**
     * Constructor.
     * @param resolver the {@link AmetysObjectResolver}.
     * @param odfPageCache the {@link ODFPageCache}.
     * @param root the odf root page.
     * @param level1Key the parent first level code (name)
     * @param name the page's name.
     * @param title the page's title.
     * @param odfPageHandler the ODF page handler.
     */
    public SecondLevelPage(AmetysObjectResolver resolver, ODFPageCache odfPageCache, Page root, String level1Key, String name, String title, OdfPageHandler odfPageHandler)
    {
        this(resolver, odfPageCache, root, level1Key, name, title, odfPageHandler, null);
    }
    
    /**
     * Constructor.
     * @param resolver the {@link AmetysObjectResolver}.
     * @param odfPageCache the {@link ODFPageCache}.
     * @param root the odf root page.
     * @param level1Key the parent first level code (name)
     * @param name the page's name.
     * @param title the page's title.
     * @param odfPageHandler the ODF page handler.
     * @param firstLevelPage The parent first level page.
     */
    public SecondLevelPage(AmetysObjectResolver resolver, ODFPageCache odfPageCache, Page root, String level1Key, String name, String title, OdfPageHandler odfPageHandler, FirstLevelPage firstLevelPage)
    {
        _resolver = resolver;
        _odfPageCache = odfPageCache;
        _root = root;
        _name = name;
        _title = title;
        _level1 = level1Key;
        _odfPageHandler = odfPageHandler;
        _level1Page = firstLevelPage;
    }
    
    @Override
    public int getDepth() throws AmetysRepositoryException
    {
        return _root.getDepth() + 2;
    }

    @Override
    public Set<String> getReferers() throws AmetysRepositoryException
    {
        return null;
    }

    @Override
    public ResourceCollection getRootAttachments() throws AmetysRepositoryException
    {
        return null;
    }

    @Override
    public String getTemplate() throws AmetysRepositoryException
    {
        // TODO
        return "program-list";
    }

    @Override
    public String getTitle() throws AmetysRepositoryException
    {
        return _title;
    }
    
    @Override
    public String getLongTitle() throws AmetysRepositoryException
    {
        return getParent().getTitle() + " - "  + _title;
    }

    @Override
    public PageType getType() throws AmetysRepositoryException
    {
        return PageType.CONTAINER;
    }

    @Override
    public String getURL() throws AmetysRepositoryException
    {
        throw new UnsupportedOperationException("getURL not supported on virtual odf pages");
    }

    @Override
    public LinkType getURLType() throws AmetysRepositoryException
    {
        throw new UnsupportedOperationException("getURLType not supported on virtual odf pages");
    }

    @Override
    public Zone getZone(String name) throws UnknownZoneException, AmetysRepositoryException
    {
        if (!"default".equals(name))
        {
            throw new IllegalArgumentException("Only the zone named 'default' is actually supported on virtual program pages.");
        }
        
        return new SecondLevelZone(this);
    }

    @Override
    public AmetysObjectIterable<? extends Zone> getZones() throws AmetysRepositoryException
    {
        ArrayList<Zone> zones = new ArrayList<>();
        zones.add(new SecondLevelZone(this));
        return new CollectionIterable<>(zones);
    }

    @Override
    public boolean hasZone(String name) throws AmetysRepositoryException
    {
        return "default".equals(name);
    }

    @Override
    public AmetysObjectIterable<? extends Page> getChildrenPages() throws AmetysRepositoryException
    {
        List<ProgramPage> pages = _getChildrenFromCache()
            .orElseGet(() -> _odfPageHandler.getProgramsWithRestrictions(_root, _level1, _name, null))
            .stream()
            .map(this::_toProgramPage)
            .collect(Collectors.toList());
        
        return new CollectionIterable<>(pages);
    }
    
    private Optional<AmetysObjectIterable<Program>> _getChildrenFromCache()
    {
        return Optional.ofNullable(_odfPageCache.getProgramCache(_root, false))
            .map(firstLevelCache -> firstLevelCache.get(_level1))
            .map(secondLevelCache -> secondLevelCache.get(_name))
            .map(CollectionIterable<Program>::new);
    }
    
    private ProgramPage _toProgramPage(Program program)
    {
        return new ProgramPage(_resolver, _odfPageHandler, _root, program, null, null, this);
    }
    
    @Override
    public String getPathInSitemap() throws AmetysRepositoryException
    {
        return _root.getPathInSitemap() + "/" + getParent().getName() + "/" + getName();
    }

    @Override
    public Site getSite() throws AmetysRepositoryException
    {
        return _root.getSite();
    }

    @Override
    public String getSiteName() throws AmetysRepositoryException
    {
        return _root.getSiteName();
    }

    @Override
    public Sitemap getSitemap() throws AmetysRepositoryException
    {
        return _root.getSitemap();
    }

    @Override
    public String getSitemapName() throws AmetysRepositoryException
    {
        return _root.getSitemapName();
    }

    @SuppressWarnings("unchecked")
    @Override
    public <A extends AmetysObject> A getChild(String path) throws AmetysRepositoryException, UnknownAmetysObjectException
    {
        List<String> headQueuePath = Arrays.asList(StringUtils.split(path, "/", 2));
        String queuePath = Iterables.get(headQueuePath, 1, null); 
        
        String pageName = headQueuePath.get(0);
        
        int j = pageName.lastIndexOf("program-");
        String programName = j == -1 ? pageName : pageName.substring(j);
        
        return (A) _getChildFromCache(programName)
                .<Page>map(this::_toProgramPage)
                .map(page -> StringUtils.isEmpty(queuePath) ? page : page.getChild(queuePath))
                .orElseThrow(() -> 
                    new UnknownAmetysObjectException("There's no content named " + programName));
    }

    private Optional<Program> _getChildFromCache(String programName)
    {
        return Optional.ofNullable(_odfPageCache.getProgram(_root, _level1, _name, programName));
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public AmetysObjectIterable<? extends AmetysObject> getChildren() throws AmetysRepositoryException
    {
        return getChildrenPages();
    }

    @Override
    public boolean hasChild(String name) throws AmetysRepositoryException
    {
        return _getChildFromCache(name).isPresent();
    }
    
    @Override
    public String getId() throws AmetysRepositoryException
    {
        // E.g: odfLevel2://XA/ALL?rootId=...
        return "odfLevel2://" + _odfPageHandler.encodeLevelValue(_level1) + "/" + _odfPageHandler.encodeLevelValue(_name) + "?rootId=" + _root.getId();
    }

    @Override
    public String getName() throws AmetysRepositoryException
    {
        // E.g: arts-lettres-langues-ALL
        return FilterNameHelper.filterName(_title) + "-" + _odfPageHandler.encodeLevelValue(_name);
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public Page getParent() throws AmetysRepositoryException
    {
        return _level1Page != null ? _level1Page : (Page) _root.getChild(_odfPageHandler.encodeLevelValue(_level1));
    }

    @Override
    public String getParentPath() throws AmetysRepositoryException
    {
        return _root.getPath() + "/" + getParent().getName();
    }

    @Override
    public String getPath() throws AmetysRepositoryException
    {
        return getParentPath() + "/" + getName();
    }

    @Override
    public CompositeMetadata getMetadataHolder()
    {
        return new StaticCompositeMetadata();
    }

    @Override
    public Set<String> getTags() throws AmetysRepositoryException
    {
        return Collections.emptySet();
    }
    
    @Override
    public boolean isVisible() throws AmetysRepositoryException
    {
        return true;
    }
    
    @Override
    public AmetysObjectIterable< ? extends Page> getChildrenPages(boolean includeInvisiblePages) throws AmetysRepositoryException
    {
        return getChildrenPages();
    }
    
    @Override
    public Page getChildPageAt(int index) throws UnknownAmetysObjectException, AmetysRepositoryException
    {
        if (index < 0)
        {
            throw new AmetysRepositoryException("Child page index cannot be negative");
        }
        
        AmetysObjectIterator<? extends Page> childPages = getChildrenPages().iterator();
        
        try
        {
            childPages.skip(index);
            return childPages.next();
        }
        catch (NoSuchElementException e)
        {
            throw new UnknownAmetysObjectException("There's no child page at index " + index + " for page " + this.getId());
        }
    }
}