/*
    * Licensed to The Apereo Foundation under one or more contributor license
    * agreements. See the NOTICE file distributed with this work for additional
    * information regarding copyright ownership.
    *
    *
    * The Apereo Foundation licenses this file to you under the Educational
    * Community 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://opensource.org/licenses/ecl2.txt
   *
   * 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.opencastproject.mediapackage.selector;
  
  import org.opencastproject.mediapackage.MediaPackage;
  import org.opencastproject.mediapackage.MediaPackageElement;
  import org.opencastproject.mediapackage.MediaPackageElementFlavor;
  import org.opencastproject.mediapackage.MediaPackageElementSelector;
  import org.opencastproject.mediapackage.Publication;
  
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.Type;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.HashSet;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Optional;
  import java.util.Set;
  
  /**
   * This selector will return any <code>MediaPackageElement</code>s from a <code>MediaPackage</code> that matches the tag
   * and flavors.
   */
  public abstract class AbstractMediaPackageElementSelector<T extends MediaPackageElement> implements
          MediaPackageElementSelector<T> {
  
    /** The tags */
    protected Set<String> tags = new HashSet<String>();
  
    /** The tags to exclude */
    protected Set<String> excludeTags = new HashSet<String>();
  
    /** The flavors */
    protected List<MediaPackageElementFlavor> flavors = new ArrayList<MediaPackageElementFlavor>();
  
    /**
     * The prefix indicating that a tag should be excluded from a search for elements using
     * {@link MediaPackage#getElementsByTags(Collection)}
     */
    public static final String NEGATE_TAG_PREFIX = "-";
  
    /**
     * This base implementation will return those media package elements that match the type specified as the type
     * parameter to the class and that flavor (if specified) AND at least one of the tags (if specified) match.
     */
    @Override
    public Collection<T> select(MediaPackage mediaPackage, boolean withTagsAndFlavors) {
      return select(Arrays.asList(mediaPackage.getElements()), withTagsAndFlavors);
    }
  
    /**
     * Similar to above, but will get media package elements from the given publication instead.
     */
    @Override
    public Collection<T> select(MediaPackage mediaPackage, String publicationChannel, boolean withTagsAndFlavors) {
      Optional<Publication> publication = Arrays.stream(mediaPackage.getPublications())
          .filter(channel -> channel.getChannel().equals(publicationChannel)).findFirst();
  
      // Skip if the media package does not contain a matching publication
      if (publication.isEmpty()) {
        return new LinkedHashSet<T>();
      }
  
      List<MediaPackageElement> list = new ArrayList(Arrays.asList(publication.get().getTracks()));
      list.addAll(new ArrayList(Arrays.asList(publication.get().getAttachments())));
      list.addAll(new ArrayList(Arrays.asList(publication.get().getCatalogs())));
  
      return select(list, withTagsAndFlavors);
    }
  
    @Override
    @SuppressWarnings("unchecked")
    public Collection<T> select(List<MediaPackageElement> elements, boolean withTagsAndFlavors) {
      Set<T> result = new LinkedHashSet<T>();
  
      // If no flavors and tags are set, return empty list
      if (flavors.isEmpty() && tags.isEmpty()) {
        return result;
     }
 
     Class type = getParametrizedType(result);
     elementLoop: for (MediaPackageElement e : elements) {
 
       // Does the type match?
       if (type.isAssignableFrom(e.getClass())) {
 
         for (String tag : e.getTags()) {
           if (excludeTags.contains(tag)) {
             continue elementLoop;
           }
         }
 
         // Any of the flavors?
         boolean matchesFlavor = false;
         for (MediaPackageElementFlavor flavor : flavors) {
           if (flavor.matches(e.getFlavor())) {
             matchesFlavor = true;
             break;
           }
         }
 
         if (flavors.isEmpty()) {
           matchesFlavor = true;
         }
 
         // If the elements selection is done by tags AND flavors
         if (withTagsAndFlavors && matchesFlavor && e.containsTag(tags)) {
           result.add((T) e);
         }
         // Otherwise if only one of these parameters is necessary to select an element
         if (!withTagsAndFlavors && ((!flavors.isEmpty() && matchesFlavor)
             || (!tags.isEmpty() && e.containsTag(tags)))) {
           result.add((T) e);
         }
       }
     }
 
     return result;
   }
 
   /**
    * This constructor tries to determine the entity type from the type argument used by a concrete implementation of
    * <code>GenericHibernateDao</code>.
    * <p>
    * Note: This code will only work for immediate specialization, and especially not for subclasses.
    */
   @SuppressWarnings("unchecked")
   private Class getParametrizedType(Object object) {
     Class current = getClass();
     Type superclass;
     Class<? extends T> entityClass = null;
     while ((superclass = current.getGenericSuperclass()) != null) {
       if (superclass instanceof ParameterizedType) {
         entityClass = (Class<T>) ((ParameterizedType) superclass).getActualTypeArguments()[0];
         break;
       } else if (superclass instanceof Class) {
         current = (Class) superclass;
       } else {
         break;
       }
     }
     if (entityClass == null) {
       throw new IllegalStateException("Cannot determine entity type because " + getClass().getName()
               + " does not specify any type parameter.");
     }
     return entityClass;
   }
 
   /**
    * Sets the flavors.
    * <p>
    * Note that the order is relevant to the selection of the track returned by this selector.
    *
    * @param flavors
    *          the list of flavors
    * @throws IllegalArgumentException
    *           if the flavors list is <code>null</code>
    */
   public void setFlavors(List<MediaPackageElementFlavor> flavors) {
     if (flavors == null) {
       throw new IllegalArgumentException("List of flavors must not be null");
     }
     this.flavors = flavors;
   }
 
   /**
    * Adds the given flavor to the list of flavors.
    * <p>
    * Note that the order is relevant to the selection of the track returned by this selector.
    *
    * @param flavor
    */
   public void addFlavor(MediaPackageElementFlavor flavor) {
     if (flavor == null) {
       throw new IllegalArgumentException("Flavor must not be null");
     }
     if (!flavors.contains(flavor)) {
       flavors.add(flavor);
     }
   }
 
   /**
    * Adds the given flavor to the list of flavors.
    * <p>
    * Note that the order is relevant to the selection of the track returned by this selector.
    *
    * @param flavor
    */
   public void addFlavor(String flavor) {
     if (flavor == null) {
       throw new IllegalArgumentException("Flavor must not be null");
     }
     MediaPackageElementFlavor f = MediaPackageElementFlavor.parseFlavor(flavor);
     if (!flavors.contains(f)) {
       flavors.add(f);
     }
   }
 
   /**
    * Adds the given flavor to the list of flavors.
    * <p>
    * Note that the order is relevant to the selection of the track returned by this selector.
    *
    * @param index
    *          the position in the list
    * @param flavor
    *          the flavor to add
    */
   public void addFlavorAt(int index, MediaPackageElementFlavor flavor) {
     if (flavor == null) {
       throw new IllegalArgumentException("Flavor must not be null");
     }
     flavors.add(index, flavor);
     for (int i = index + 1; i < flavors.size(); i++) {
       if (flavors.get(i).equals(flavor)) {
         flavors.remove(i);
       }
     }
   }
 
   /**
    * Adds the given flavor to the list of flavors.
    * <p>
    * Note that the order is relevant to the selection of the track returned by this selector.
    *
    * @param index
    *          the position in the list
    * @param flavor
    *          the flavor to add
    */
   public void addFlavorAt(int index, String flavor) {
     if (flavor == null) {
       throw new IllegalArgumentException("Flavor must not be null");
     }
     MediaPackageElementFlavor f = MediaPackageElementFlavor.parseFlavor(flavor);
     flavors.add(index, f);
     for (int i = index + 1; i < flavors.size(); i++) {
       if (flavors.get(i).equals(f)) {
         flavors.remove(i);
       }
     }
   }
 
   /**
    * Removes all occurences of the given flavor from the list of flavors.
    *
    * @param flavor
    *          the flavor to remove
    */
   public void removeFlavor(MediaPackageElementFlavor flavor) {
     if (flavor == null) {
       throw new IllegalArgumentException("Flavor must not be null");
     }
     flavors.remove(flavor);
   }
 
   /**
    * Removes all occurences of the given flavor from the list of flavors.
    *
    * @param flavor
    *          the flavor to remove
    */
   public void removeFlavor(String flavor) {
     if (flavor == null) {
       throw new IllegalArgumentException("Flavor must not be null");
     }
     flavors.remove(MediaPackageElementFlavor.parseFlavor(flavor));
   }
 
   /**
    * Removes all occurences of the given flavor from the list of flavors.
    *
    * @param index
    *          the position in the list
    */
   public void removeFlavorAt(int index) {
     flavors.remove(index);
   }
 
   /**
    * Returns the list of flavors.
    *
    * @return the flavors
    */
   public MediaPackageElementFlavor[] getFlavors() {
     return flavors.toArray(new MediaPackageElementFlavor[flavors.size()]);
   }
 
   /**
    * Adds <code>tag</code> to the list of tags that are used to select the media.
    *
    * @param tag
    *          the tag to include
    */
   public void addTag(String tag) {
     if (tag.startsWith(NEGATE_TAG_PREFIX)) {
       excludeTags.add(tag.substring(NEGATE_TAG_PREFIX.length()));
     } else {
       tags.add(tag);
     }
   }
 
   /**
    * Adds <code>tag</code> to the list of tags that are used to select the media.
    *
    * @param tag
    *          the tag to include
    */
   public void removeTag(String tag) {
     tags.remove(tag);
   }
 
   /**
    * Returns the tags.
    *
    * @return the tags
    */
   public String[] getTags() {
     return tags.toArray(new String[tags.size()]);
   }
 
   /**
    * Removes all of the tags from this selector.
    */
   public void clearTags() {
     tags.clear();
   }
 
 }