/*
 *  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.odf.courselist;

import java.util.ArrayList;
import java.util.List;
import java.util.Set;

import javax.jcr.Node;

import org.apache.commons.lang3.ArrayUtils;

import org.ametys.odf.course.Course;
import org.ametys.odf.course.CourseContainer;
import org.ametys.odf.program.AbstractProgramPart;
import org.ametys.odf.program.Program;
import org.ametys.plugins.repository.UnknownAmetysObjectException;
import org.ametys.plugins.repository.metadata.UnknownMetadataException;

/**
 * Class representing a list of {@link Course}
 */
public class CourseList extends AbstractProgramPart<CourseListFactory> implements CourseContainer
{
    /** Constants for choice type metadata */
    public static final String METADATA_CHOICE_TYPE = "choiceType";
    /** Constants for minimum number of courses. This metadata is valued only if type is {@link ChoiceType}.CHOICE */
    public static final String METADATA_MIN_COURSES = "min";
    /** Constants for maximum number of courses. This metadata is valued only if type is {@link ChoiceType}.CHOICE */
    public static final String METADATA_MAX_COURSES = "max";
    /** Constants for child courses metadata */
    public static final String METADATA_CHILD_COURSES = "courses";
    /** Name of the metadata holding the direct parent courses */
    public static final String METADATA_PARENT_COURSES = "parentCourses";
    
    /**
     * The type of the {@link CourseList}
     */
    public enum ChoiceType
    {
        /** mandatory type */
        MANDATORY,
        /** optional type */
        OPTIONAL,
        /** choice type */
        CHOICE
    }

    /**
     * Constructor
     * @param node The JCR node
     * @param parentPath The parent path
     * @param factory the factory
     */
    public CourseList(Node node, String parentPath, CourseListFactory factory)
    {
        super(node, parentPath, factory);
    }

    @Override
    public List<Course> getCourses()
    {
        List<Course> courses = new ArrayList<>();
        
        String[] courseIds = getMetadataHolder().getStringArray(METADATA_CHILD_COURSES, new String[0]);
        for (String id : courseIds)
        {
            try
            {
                Course course = _getFactory()._getResolver().resolveById(id);
                courses.add(course);
            }
            catch (UnknownAmetysObjectException e)
            {
                // Nothing
            }
        }
        
        return courses;
    }

    @Override
    public boolean containsCourse(String courseId)
    {
        try
        {
            String[] courseIds = getMetadataHolder().getStringArray(METADATA_CHILD_COURSES, new String[0]);
            return ArrayUtils.contains(courseIds, courseId);
        }
        catch (UnknownMetadataException e)
        {
            return false;
        }
    }
    
    @Override
    public boolean hasCourses()
    {
        return getMetadataHolder().getStringArray(METADATA_CHILD_COURSES, new String[0]).length > 0;
    }
    
    // --------------------------------------------------------------------------------------//
    // GETTERS AND SETTERS
    // --------------------------------------------------------------------------------------//
    /**
     * If this set of teaching unit element is a type of choice this method
     * return the minimum number of teaching unit elements that the student must
     * choose else -1.
     * 
     * @return the minimum number of teaching unit element that the student must choose. 0 if not set
     */
    public long getMinNumberOfCourses()
    {
        return getMetadataHolder().getLong(CourseList.METADATA_MIN_COURSES, 0);
    }

    /**
     * If this set of teaching unit element is a type of choice this method
     * return the maximum number of teaching unit element that this set of
     * teaching unit element must contains else -1.
     * 
     * @return the maximum number of teaching unit element that this set of
     *         teaching unit element must contains.
     */
    public long getMaxNumberOfCourses()
    {
        return getMetadataHolder().getLong(CourseList.METADATA_MAX_COURSES, 0);
    }
    
    /**
     * Indicates whether the teaching unit elements contained are mandatory,
     * optional or a choice.
     * 
     * @return the type of the teaching unit elements contained.
     */
    public ChoiceType getType()
    {
        try
        {
            return ChoiceType.valueOf(getMetadataHolder().getString(CourseList.METADATA_CHOICE_TYPE));
        }
        catch (IllegalArgumentException e)
        {
            // No corresponding choice
            return null;
        }
        catch (UnknownMetadataException e)
        {
            return null;
        }
    }

    /**
     * Get the ids of parent courses
     * @return the ids of parent courses
     */
    public List<Course> getParentCourses()
    {
        List<Course> parentCourses = new ArrayList<>();
        
        String[] parentId = getMetadataHolder().getStringArray(METADATA_PARENT_COURSES, new String[0]);
        for (String id : parentId)
        {
            try
            {
                Course course = _getFactory()._getResolver().resolveById(id);
                parentCourses.add(course);
            }
            catch (UnknownAmetysObjectException e)
            {
                // Nothing
            }
        }
        
        return parentCourses;
    }
        
    @Override
    public Set<Program> getRootPrograms()
    {
        Set<Program> rootPrograms = super.getRootPrograms();
        for (Course course : getParentCourses())
        {
            rootPrograms.addAll(course.getRootPrograms());
        }
        return rootPrograms;
    }
    
    // --------------------------------------------------------------------------------------//
    // CDM-fr
    // --------------------------------------------------------------------------------------//
    @Override
    protected String getCDMType()
    {
        return "CL";
    }
}