/*
 *  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.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.repository.AmetysObject;
import org.ametys.plugins.repository.AmetysObjectIterable;
import org.ametys.plugins.repository.AmetysRepositoryException;
import org.ametys.plugins.repository.CollectionIterable;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.data.holder.ModelLessDataHolder;
import org.ametys.plugins.repository.data.holder.impl.DefaultModelLessDataHolder;
import org.ametys.plugins.repository.data.repositorydata.RepositoryData;
import org.ametys.plugins.repository.data.repositorydata.impl.MemoryRepositoryData;
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 extends AbstractOdfPage
{
    private Page _root;
    private AbstractProgram _program;
    private String _path;
    private Program _parent;
    private Page _parentPage;
    private ProgramPageFactory _factory;
    
    /**
     * Constructor for program page holding a {@link Program}.
     * @param factory The factory
     * @param root the ODF root page.
     * @param program the program.
     * @param parentPage the parent {@link Page} or null if not yet computed.
     */
    public ProgramPage(ProgramPageFactory factory, Page root, Program program, Page parentPage)
    {
        this(factory, root, program, null, null, parentPage);
    }
    
    /**
     * Constructor for program page holding a {@link Program} or {@link SubProgram}
     * @param factory The factory
     * @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(ProgramPageFactory factory, Page root, AbstractProgram program, String path, Program parent, Page parentPage)
    {
        _factory = factory;
        _root = root;
        _program = program;
        _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
    {
        int levelDepth = 0;
        if (StringUtils.isNotBlank(_factory.getODFPageHandler().getLevel1Metadata(_root)))
        {
            levelDepth++;
            if (StringUtils.isNotBlank(_factory.getODFPageHandler().getLevel2Metadata(_root)))
            {
                levelDepth++;
            }
        }
        
        return _root.getDepth() + levelDepth + (_path != null ? _path.split("/").length : 0);
    }

    @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 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, _factory.getZoneDataTypeEP(), _factory.getZoneItemDataTypeEP());
    }

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

    @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();
        return _factory.getODFPageHandler().computeLevelsPath(_root, parentProgram);
    }
    
    @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); 
        
        Optional<Page> childPage = _getChildPage(_program, name);
        if (childPage.isPresent())
        {
            if (StringUtils.isEmpty(queuePath))
            {
                if (name.lastIndexOf("subprogram-") != -1)
                {
                    // Support of legacy pattern with the program's name (instead of program's code)
                    return (A) new RedirectPage(childPage.get());
                }
                else
                {
                    return (A) childPage.get();
                }
            }
            else
            {
                if (name.lastIndexOf("subprogram-") != -1)
                {
                    // Support of legacy pattern with the program's name (instead of program's code)
                    return (A) new RedirectPage((Page) childPage.get().getChild(queuePath));
                }
                else
                {
                    return (A) childPage.get().getChild(queuePath);
                }
            }
        }
        else
        {
            throw 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.getCode();
            if (name.equals(subProgramPageName))
            {
                return true;
            }
            else
            {
                // For legacy purpose
                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(_factory, _root, child, _path != null ? _path + '/' + getName() : getName(), getParentProgram(), this);
    }
    
    private CoursePage _toChildCoursePage(Course course)
    {
        return new CoursePage(_factory.getCoursePageFactory(), _root, course, getParentProgram(), _path != null ? _path + '/' + getName() : getName(), this);
    }
    
    @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-H7AIIUYW
        return FilterNameHelper.filterName(_program.getTitle()) + "-" + _program.getCode();
    }

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

    @Override
    public String getParentPath() throws AmetysRepositoryException
    {
        if (StringUtils.isBlank(_factory.getODFPageHandler().getLevel1Metadata(_root)))
        {
            return _root.getPath();
        }
        else
        {
            return _root.getPath() + '/' + _computeLevelsPath() + (_path != null ? "/" + _path : "");
        }
    }

    public ModelLessDataHolder getDataHolder()
    {
        RepositoryData repositoryData = new MemoryRepositoryData(getName());
        return new DefaultModelLessDataHolder(_factory.getPageDataTypeEP(), repositoryData);
    }

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