/*
 *  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.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Optional;
import java.util.Queue;
import java.util.Set;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;

import org.ametys.cms.FilterNameHelper;
import org.ametys.odf.ProgramItem;
import org.ametys.odf.course.Course;
import org.ametys.odf.courselist.CourseList;
import org.ametys.odf.program.AbstractProgram;
import org.ametys.odf.program.Container;
import org.ametys.odf.program.Program;
import org.ametys.odf.program.SubProgram;
import org.ametys.odf.program.TraversableProgramPart;
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 {@link Program} or a {@link SubProgram}.
 */
public class ProgramPage implements Page
{
    private AmetysObjectResolver _resolver;
    private OdfPageHandler _odfPageHandler;
    private Page _root;
    private AbstractProgram _program;
    private String _path;
    private Program _parent;
    private Page _parentPage;
    
    /**
     * Constructor for program page holding a {@link Program}.
     * @param resolver the {@link AmetysObjectResolver}.
     * @param odfPageHandler the {@link OdfPageHandler} to handle ODF pages.
     * @param root the ODF root page.
     * @param program the program.
     * @param parentPage the parent {@link Page} or null if not yet computed.
     */
    public ProgramPage(AmetysObjectResolver resolver, OdfPageHandler odfPageHandler, Page root, Program program, Page parentPage)
    {
        this(resolver, odfPageHandler, root, program, null, null, parentPage);
    }
    
    /**
     * Constructor for program page holding a {@link Program} or {@link SubProgram}
     * @param resolver the {@link AmetysObjectResolver}.
     * @param odfPageHandler the {@link OdfPageHandler} to handle ODF pages.
     * @param root the ODF root page.
     * @param program the program or subprogram.
     * @param path The path from the virtual second level page. Can be null if abstract program is a {@link Program}
     * @param parent the parent program in case of a subprogram, null otherwise
     * @param parentPage the parent {@link Page} or null if not yet computed.
     */
    public ProgramPage(AmetysObjectResolver resolver, OdfPageHandler odfPageHandler, Page root, AbstractProgram program, String path, Program parent, Page parentPage)
    {
        _root = root;
        _program = program;
        _resolver = resolver;
        _odfPageHandler = odfPageHandler;
        _path = path;
        _parent = parent;
        _parentPage = parentPage;
    }
    
    /**
     * Returns the associated {@link Program} or {@link SubProgram}.
     * @return the associated {@link Program} or {@link SubProgram}.
     */
    public AbstractProgram getProgram()
    {
        return _program;
    }
    
    @Override
    public int getDepth() throws AmetysRepositoryException
    {
        return _root.getDepth() + 2 + (_path != null ? _path.split("/").length : 0);
    }

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

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

    @Override
    public String getTemplate() throws AmetysRepositoryException
    {
        return "program";
    }

    @Override
    public String getTitle() throws AmetysRepositoryException
    {
        return _program.getTitle();
    }

    @Override
    public String getLongTitle() throws AmetysRepositoryException
    {
        return _program.getTitle();
    }
 
    @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 ProgramZone(this);
    }

    @Override
    public AmetysObjectIterable< ? extends Zone> getZones() throws AmetysRepositoryException
    {
        ArrayList<Zone> zones = new ArrayList<>();
        zones.add(new ProgramZone(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
    {
        Collection<Page> children = _traverseChildren(_program)
            .distinct()
            .map(child -> _toChildPage(child))
            .collect(Collectors.toList());
        
        return new CollectionIterable<>(children);
    }
    
    @Override
    public String getPathInSitemap() throws AmetysRepositoryException
    {
        return Stream.of(_root.getPathInSitemap(), _computeLevelsPath(), _path, getName())
            .filter(StringUtils::isNotEmpty)
            .collect(Collectors.joining("/"));
    }
    
    Program getParentProgram()
    {
        return Optional.ofNullable(_parent)
            .orElseGet(() -> (Program) _program);
    }

    /**
     * Compute the path from the root odf page, representing the first and second level pages.
     * @return the path
     */
    String _computeLevelsPath()
    {
        // Get the parent program holding the level values
        Program parentProgram = getParentProgram();
        
        String level1 = _odfPageHandler.getProgramLevel1Value(_root, parentProgram);
        String level2 = _odfPageHandler.getProgramLevel2Value(_root, parentProgram);
        
        // The path is no more valid, re-calculate the real path
        String secondLevelPageId = "odfLevel2://" + level1 + "/" + level2 + "?rootId=" + _root.getId();
        Page secondLevelPage = _resolver.resolveById(secondLevelPageId);
        
        return secondLevelPage.getParent().getName() + "/" + secondLevelPage.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
    {
        if (path.isEmpty())
        {
            throw new AmetysRepositoryException("path must be non empty");
        }
        
        List<String> headQueuePath = Arrays.asList(StringUtils.split(path, "/", 2));
        String name = headQueuePath.get(0);
        String queuePath = Iterables.get(headQueuePath, 1, null); 
        
        return (A) _getChildPage(_program, name)
                .map(page -> StringUtils.isEmpty(queuePath) ? page : page.getChild(queuePath))
                .orElseThrow(() -> 
                    new UnknownAmetysObjectException("Unknown child page '" + path + "' for page " + getId()));
    }
    
    private Optional<Page> _getChildPage(TraversableProgramPart parent, String name)
    {
        return _findChild(parent, name)
                .map(child -> _toChildPage(child));
    }
    
    private Optional<ProgramItem> _findChild(TraversableProgramPart parent, String name)
    {
        return _traverseChildren(parent)
            .filter(child -> _filterByName(child, name))
            .findFirst();
    }
    
    private boolean _filterByName(ProgramItem programItem, String name)
    {
        if (programItem instanceof SubProgram)
        {
            String subProgramPageName = FilterNameHelper.filterName(((SubProgram) programItem).getTitle()) + "-" + programItem.getName();
            return name.equals(subProgramPageName);
        }
        else if (programItem instanceof Course)
        {
            Course course = (Course) programItem;
            String coursePageName = FilterNameHelper.filterName(course.getTitle()) + "-" + course.getCode();
            return name.equals(coursePageName);
        }
        
        return false;
    }
    
    private Page _toChildPage(ProgramItem child)
    {
        if (child instanceof SubProgram)
        {
            return _toChildProgramPage((SubProgram) child);
        }
        else if (child instanceof Course)
        {
            return _toChildCoursePage((Course) child);
        }
        
        return null;
    }
    
    private ProgramPage _toChildProgramPage(SubProgram child)
    {
        return new ProgramPage(_resolver, _odfPageHandler, _root, child, _path != null ? _path + '/' + getName() : getName(), getParentProgram(), this);
    }
    
    private CoursePage _toChildCoursePage(Course course)
    {
        return new CoursePage(_resolver, _odfPageHandler, _root, course, getParentProgram(), _path != null ? _path + '/' + getName() : getName(), this);
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public AmetysObjectIterable<? extends Page> getChildren() throws AmetysRepositoryException
    {
        return getChildrenPages();
    }

    @Override
    public boolean hasChild(String name) throws AmetysRepositoryException
    {
        return _findChild(_program, name).isPresent();
    }
    
    @Override
    public String getId() throws AmetysRepositoryException
    {
        // E.g: program://_root?rootId=xxxx&programId=xxxx (for a program)
        // E.g: program://path/to/subprogram?rootId=xxxx&programId=xxxx&parentId=xxxx (for a subprogram)
        StringBuilder sb = new StringBuilder("program://");
        sb.append(StringUtils.isNotEmpty(_path) ? _path : "_root");
        sb.append("?rootId=").append(_root.getId());
        sb.append("&programId=").append(_program.getId());
        
        if (_parent != null)
        {
            sb.append("&parentId=").append(_parent.getId());
        }
        
        return sb.toString();
    }

    @Override
    public String getName() throws AmetysRepositoryException
    {
        // E.g: licence-lea-anglais-allemand-program-fruai3182988abcde07
        return FilterNameHelper.filterName(_program.getTitle()) + "-" + _program.getName();
    }

    @SuppressWarnings("unchecked")
    @Override
    public Page getParent() throws AmetysRepositoryException
    {
        if (_parentPage == null)
        {
            String relParentPath = _computeLevelsPath() + (_path != null ? "/" + _path : "");
            _parentPage = _root.getChild(relParentPath);
        }
        
        return _parentPage;
    }

    @Override
    public String getParentPath() throws AmetysRepositoryException
    {
        return _root.getPath() + '/' + _computeLevelsPath() + (_path != null ? "/" + _path : "");
    }

    @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();
    }

    public Page getChildPageAt(int index) throws UnknownAmetysObjectException, AmetysRepositoryException
    {
        // TODO make a default method or call a helper instead of duplicate the code into each Page (FirstLevel / SecondLevel / Program etc...)
        
        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());
        }
    }
    
    private Stream<ProgramItem> _traverseChildren(TraversableProgramPart parent)
    {
        Predicate<ProgramItem> isSubProgram = SubProgram.class::isInstance;
        Predicate<ProgramItem> isCourse = Course.class::isInstance;
        
        ProgramPartTraverser traverser = new ProgramPartTraverser(parent.getProgramPartChildren());
        return traverser.stream().filter(isSubProgram.or(isCourse));
    }
    
    /**
     * Program part traverser. Iterate recursively on child program base.
     */
    static class ProgramPartTraverser extends AbstractTreeIterator<ProgramItem>
    {
        public ProgramPartTraverser(Collection<? extends ProgramItem> programPartChildren)
        {
            super(programPartChildren);
        }

        @Override
        protected Iterator<ProgramItem> provideChildIterator(ProgramItem parent)
        {
            if (parent instanceof CourseList)
            {
                CourseList courseList = (CourseList) parent;
                return new ProgramPartTraverser(courseList.getCourses());
            }
            
            if (parent instanceof Container)
            {
                Container container = (Container) parent;
                return new ProgramPartTraverser(container.getProgramPartChildren());
            }
            
            return null;
        }
    }
    
    /**
     * Breadth first search iterator for tree structure
     * Each node can provide an iterator that will be put in the end of the queue. 
     * @param <T> A tree item
     */
    abstract static class AbstractTreeIterator<T> implements Iterator<T>
    {
        protected final Queue<Iterator<T>> _nodeIterators = new LinkedList<>();
        private Boolean _hasNext;
        
        AbstractTreeIterator(Iterator<T> iterator)
        {
            if (iterator != null && iterator.hasNext())
            {
                _nodeIterators.add(iterator);
            }
        }
        
        AbstractTreeIterator(Collection<? extends T> children)
        {
            this(handleConstructorChildren(children));
        }
        
        private static <T> Iterator<T> handleConstructorChildren(Collection<? extends T> children)
        {
            Collection<T> tChildren = Collections.unmodifiableCollection(children);
            return tChildren.iterator();
        }
        
        public boolean hasNext()
        {
            if (_hasNext != null)
            {
                return _hasNext;
            }
            
            Iterator<T> it = _getOrUpdateHead();
            if (_hasNext == null)
            {
                _hasNext = it != null ? it.hasNext() : false;
            }
            
            return _hasNext;
        }
        
        public T next()
        {
            if (BooleanUtils.isFalse(_hasNext))
            {
                throw new NoSuchElementException();
            }
            
            Iterator<T> it = null;
            if (_hasNext == null)
            {
                it = _getOrUpdateHead();
            }
            else
            {
                it = _nodeIterators.peek();
            }
            
            T next = Optional.ofNullable(it)
                .map(Iterator::next)
                .orElseThrow(NoSuchElementException::new);
            
            Iterator<T> childIterator = provideChildIterator(next);
            if (childIterator != null && childIterator.hasNext())
            {
                _nodeIterators.add(childIterator);
            }
            
            // reset cached has next
            _hasNext = null;
            
            return next;
        }
        
        protected abstract Iterator<T> provideChildIterator(T next);
        
        public Stream<T> stream()
        {
            Iterable<T> iterable = () -> this;
            return StreamSupport.stream(iterable.spliterator(), false);
        }
        
        private Iterator<T> _getOrUpdateHead()
        {
            return Optional.ofNullable(_nodeIterators.peek())
                .filter(it ->
                {
                    if (it.hasNext())
                    {
                        _hasNext = true;
                        return true;
                    }
                    
                    return false;
                })
                .orElseGet(() -> _updateHead());
        }
        
        private Iterator<T> _updateHead()
        {
            _nodeIterators.poll(); // remove actual head
            return _nodeIterators.peek();
        }
    }
}