/*
 *  Copyright 2019 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.service.search;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Deque;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.stream.Collectors;

import org.apache.cocoon.xml.XMLUtils;
import org.slf4j.Logger;
import org.xml.sax.ContentHandler;
import org.xml.sax.SAXException;

import org.ametys.cms.repository.Content;
import org.ametys.core.util.DateUtils;
import org.ametys.odf.ODFHelper;
import org.ametys.odf.ProgramItem;
import org.ametys.odf.course.Course;
import org.ametys.odf.program.Program;
import org.ametys.plugins.repository.AmetysObject;
import org.ametys.web.frontoffice.search.metamodel.ReturnableSaxer;
import org.ametys.web.frontoffice.search.metamodel.impl.PageReturnable;
import org.ametys.web.frontoffice.search.metamodel.impl.PageSaxer;
import org.ametys.web.frontoffice.search.requesttime.SearchComponentArguments;

/**
 * {@link ReturnableSaxer} for {@link CourseReturnable}
 * <br>
 * <br>Note for developpers: This Saxer extends PageSaxer to have access to its protected method #saxContent()
 */
public class CourseSaxer extends PageSaxer
{
    private CourseReturnable _courseReturnable;

    /**
     * Constructor
     * @param pageReturnable The course returnable (needed for superclass)
     * @param courseReturnable The associated returnable on courses
     */
    public CourseSaxer(PageReturnable pageReturnable, CourseReturnable courseReturnable)
    {
        super(pageReturnable);
        _courseReturnable = courseReturnable;
    }
    
    @Override
    public boolean canSax(AmetysObject hit, Logger logger, SearchComponentArguments args)
    {
        return hit instanceof Course;
    }
    
    @Override
    public void sax(ContentHandler contentHandler, AmetysObject hit, Logger logger, SearchComponentArguments args) throws SAXException
    {
        Course course = (Course) hit;
        _saxCourseContent(contentHandler, course, logger, args);
        _saxCoursePages(contentHandler, course);
    }
    
    private void _saxCourseContent(ContentHandler contentHandler, Course course, Logger logger, SearchComponentArguments args) throws SAXException
    {
        XMLUtils.createElement(contentHandler, "title", course.getTitle());
        Date lastValidationDate = course.getLastValidationDate();
        if (lastValidationDate != null)
        {
            XMLUtils.createElement(contentHandler, "lastValidation", DateUtils.dateToString(lastValidationDate));
        }
        Locale locale = new Locale(args.currentPage().getSitemapName());
        saxContent(course, "index", locale, contentHandler, logger);
    }
    
    private void _saxCoursePages(ContentHandler contentHandler, Course course) throws SAXException
    {
        CoursePathSaxer coursePathSaxer = new CoursePathSaxer(contentHandler);
        
        List<CoursePagePath> coursePagePaths = new CoursePagePathsRetriever(_courseReturnable._odfHelper).retrieve(course);
        
        for (CoursePagePath coursePagePath : coursePagePaths)
        {
            String uri = coursePagePath.toUri();
            String resolvedUri = _courseReturnable._odfURIResolver.resolve(uri, false, false, false);
            
            XMLUtils.startElement(contentHandler, "coursePage");
            XMLUtils.createElement(contentHandler, "uri", uri);
            XMLUtils.createElement(contentHandler, "resolvedUri", resolvedUri);
            coursePathSaxer.saxPathTitles(coursePagePath);
            XMLUtils.endElement(contentHandler, "coursePage");
        }
    }
    
    static class CoursePagePathsRetriever
    {
        private ODFHelper _odfHelper;

        CoursePagePathsRetriever(ODFHelper odfHelper)
        {
            _odfHelper = odfHelper;
        }
        
        List<CoursePagePath> retrieve(Course course)
        {
            return _getCoursePagePaths(course)
                    .stream()
                    .distinct()
                    .collect(Collectors.toList());
        }
        
        private List<CoursePagePath> _getCoursePagePaths(Course course)
        {
            CoursePagePath base = new CoursePagePath(course);
            List<CoursePagePath> incompletePaths = new ArrayList<>(Collections.singletonList(base));
            List<CoursePagePath> completePaths = new ArrayList<>();
            
            while (!incompletePaths.isEmpty())
            {
                completePaths.addAll(_tryCompletePaths(incompletePaths));
            }
            
            return completePaths;
        }
        
        private List<CoursePagePath> _tryCompletePaths(List<CoursePagePath> incompletePaths)
        {
            List<CoursePagePath> completePaths = new ArrayList<>();
            List<CoursePagePath> newIncompletePaths = new ArrayList<>();
            
            for (CoursePagePath incompletePath : incompletePaths)
            {
                List<CoursePagePath> pathsOnParentsLevel = _pathsOnParentsLevel(incompletePath);
                _determineIfComplete(pathsOnParentsLevel, completePaths, newIncompletePaths);
            }
            
            incompletePaths.clear();
            incompletePaths.addAll(newIncompletePaths);
            return completePaths;
        }
        
        private List<CoursePagePath> _pathsOnParentsLevel(CoursePagePath incompletePath)
        {
            ProgramItem lastItem = incompletePath.lastItem();
            return _odfHelper.getParentAbstractPrograms(lastItem)
                    .stream()
                    .map(item -> new CoursePagePath(incompletePath).addParent(item))
                    .collect(Collectors.toList());
        }
        
        private void _determineIfComplete(List<CoursePagePath> pathsOnParentsLevel, List<CoursePagePath> completePaths, List<CoursePagePath> newIncompletePaths)
        {
            for (CoursePagePath pathOnParentLevel : pathsOnParentsLevel)
            {
                if (pathOnParentLevel.lastItem() instanceof Program)
                {
                    completePaths.add(pathOnParentLevel);
                }
                else
                {
                    newIncompletePaths.add(pathOnParentLevel);
                }
            }
        }
    }
    
    
    static class CoursePagePath
    {
        private Deque<ProgramItem> _items = new ArrayDeque<>(); // sorted from deep in the hierarchy (course) to high in the hierarchy (program)
        
        CoursePagePath(CoursePagePath other)
        {
            _items = new ArrayDeque<>(other._items);
        }
        
        CoursePagePath(Course course)
        {
            _items.addLast(course);
        }
        
        CoursePagePath addParent(ProgramItem parent)
        {
            _items.addLast(parent);
            return this;
        }
        
        ProgramItem lastItem()
        {
            return _items.getLast();
        }
        
        String toUri()
        {
            return _items
                    .stream()
                    .map(ProgramItem::getId)
                    .collect(Collectors.joining(";"));
        }
        
        Collection<ProgramItem> fromProgramToCourseItems()
        {
            ArrayList<ProgramItem> result = new ArrayList<>(_items);
            Collections.reverse(result);
            return result;
        }

        @Override
        public int hashCode()
        {
            return Objects.hash(_items);
        }

        @Override
        public boolean equals(Object obj)
        {
            if (this == obj)
            {
                return true;
            }
            if (obj == null)
            {
                return false;
            }
            if (getClass() != obj.getClass())
            {
                return false;
            }
            CoursePagePath other = (CoursePagePath) obj;
            return Objects.equals(_items, other._items);
        }
    }
    
    static class CoursePathSaxer
    {
        private ContentHandler _contentHandler;

        CoursePathSaxer(ContentHandler contentHandler)
        {
            _contentHandler = contentHandler;
        }
        
        void saxPathTitles(CoursePagePath coursePagePath) throws SAXException
        {
            XMLUtils.startElement(_contentHandler, "path");
            for (ProgramItem programItem : coursePagePath.fromProgramToCourseItems())
            {
                if (programItem instanceof Content)
                {
                    XMLUtils.createElement(_contentHandler, "element", ((Content) programItem).getTitle());
                }
            }
            XMLUtils.endElement(_contentHandler, "path");
        }
    }
}