/******************************************************************************
    * Library.java - domain object for the entire library.
    * $Id: Library.java,v 1.16 2015/05/11 18:02:01 dick Exp $
    * 
    * BuckoVidLib - The BuckoSoft Video Library
    * Copyright(c) 2014 - Dick Balaska
    * 
    * $Log: Library.java,v $
    * Revision 1.16  2015/05/11 18:02:01  dick
   * Fix the maxRecentVideos test.
   *
   * Revision 1.15  2015/05/11 17:50:01  dick
   * Bump up maxNewestVideos to 100.
   *
   * Revision 1.14  2015/04/30 06:34:27  dick
   * Getting lists of VideoBase is always protected by session.
   *
   * Revision 1.13  2015/04/30 03:18:04  dick
   * Deal mostly with VideoBase. Only fetch full Video when we really need it.
   * Protect all (most) calls to the restricted section of the library by session.
   *
   * Revision 1.12  2015/04/28 16:16:21  dick
   * Keep a list of the restricted LibrarySection names handy.
   *
   * Revision 1.11  2015/04/27 14:59:12  dick
   * Support having restricted LibrarySections that you must have access to get to.
   *
   * Revision 1.10  2015/04/02 23:24:37  dick
   * Handle Writers.  Store the hashKey with the Video.
   *
   * Revision 1.9  2015/04/01 02:41:22  dick
   * Library keeps a list of Actors, Directors and Genres.
   *
   * Revision 1.8  2015/03/21 09:17:32  dick
   * getLibrarySection(key) returns one LibrarySection.
   *
   * Revision 1.7  2014/11/01 08:05:05  dick
   * Count TV episodes.
   *
   * Revision 1.6  2014/10/25 22:51:49  dick
   * Keep a list of newest videos, in case we want more than just the most recent.
   *
   * Revision 1.5  2014/10/20 01:19:02  dick
   * Track the newestVideo in the library.  Track TVSeasons.
   *
   * Revision 1.4  2014/10/09 08:34:35  dick
   * Use the Video as a key for the client, not just the image url.
   *
   * Revision 1.3  2014/10/08 04:24:40  dick
   * Resurrect Library to respresent the entire library.
   *
   */
  package com.buckosoft.BuckoVidLib.domain;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.ListIterator;
  
  /** Domain object for the entire library.
   * Library has no knowledge of how to deal with resticted sections, other than to keep a list of them.
   * That job is LibraryManager's.
   * @author dick
   * @since 2014-10-07
   */
  public class Library {
  	private List<LibrarySection>	librarySections = new ArrayList<LibrarySection>();
  	private List<LibrarySection>	unrestrictedLibrarySections = new ArrayList<LibrarySection>();
  	private	List<String>			restrictedSectionNames = new ArrayList<String>();
  
  	private	HashMap<Integer, VideoBase> videoMap = new HashMap<Integer, VideoBase>();
  	private	HashMap<Integer, Integer>	mapVideoIdtoHashKey = new HashMap<Integer, Integer>();
  	private	HashSet<Actor>		actors = new HashSet<Actor>();
  	private	HashSet<Director>	directors = new HashSet<Director>();
  	private	HashSet<Genre>		genres = new HashSet<Genre>();
  	private	HashSet<Writer>		writers = new HashSet<Writer>();
  	
  	private	LinkedList<VideoBase>	newestVideos = new LinkedList<VideoBase>();
  	private	final int			maxNewestVideos = 100;
  	
  //	private	Video	newestVideo;	// or TV Show
  
  	
  	/** Fetch the max length of the recent video list.
  	 * @return the maxNewestVideos
  	 */
  	public int getMaxNewestVideos() {
  		return maxNewestVideos;
  	}
  	
  	/**
  	 * @return the librarySections
  	 */
  	public List<LibrarySection> getLibrarySections() {
  		return librarySections;
  	}
  	public List<LibrarySection> getUnrestrictedLibrarySections() {
 		return(unrestrictedLibrarySections);
 	}
 	public LibrarySection getLibrarySection(int key) {
 		for (LibrarySection ls : librarySections) {
 			if (ls.getKey() == key)
 				return(ls);
 		}
 		return(null);
 	}
 	/**
 	 * @param librarySections the librarySections to set
 	 */
 	public void setLibrarySections(List<LibrarySection> librarySections) {
 		this.librarySections = librarySections;
 		this.unrestrictedLibrarySections.clear();
 		for (LibrarySection ls : librarySections)
 			if (!ls.isRestricted())
 				this.unrestrictedLibrarySections.add(ls);
 	}
 
 	public void addLibrarySection(LibrarySection librarySection) {
 		this.librarySections.add(librarySection);
 		if (!librarySection.isRestricted())
 			this.unrestrictedLibrarySections.add(librarySection);
 	}
 
 	/**
 	 * @return the restrictedSectionNames
 	 */
 	public List<String> getRestrictedSectionNames() {
 		return restrictedSectionNames;
 	}
 	/**
 	 * @param restrictedSectionNames the restrictedSectionNames to set
 	 */
 	public void setRestrictedSectionNames(List<String> restrictedSectionNames) {
 		this.restrictedSectionNames = restrictedSectionNames;
 	}
 
 	/**
 	 * @return the videoMap
 	 */
 	public HashMap<Integer, VideoBase> getVideoMap() {
 		return videoMap;
 	}
 
 	/**
 	 * @param videoMap the videoMap to set
 	 */
 //	public void setVideoMap(HashMap<Integer, Video> videoMap) {
 //		this.videoMap = videoMap;
 //	}
 	
 	public void addVideo(int key, VideoBase video) {
 		videoMap.put(key, video);
 		this.mapVideoIdtoHashKey.put(video.getId(), key);
 /*		if (video instanceof TVShow) {
 			TVShow tv = (TVShow)video;
 			for (TVSeason season : tv.getSeasons()) {
 				if (season.getAddedAt() > newestVideo.getAddedAt()) {
 					video = season;
 				}
 			}
 		}
 */
 		/* head is newest.  head: 100, tail: 50 */
 		if (newestVideos.isEmpty())	{
 			newestVideos.add(video);
 		} else if (video.getAddedAt() > newestVideos.getLast().getAddedAt()
 				|| newestVideos.size() < maxNewestVideos) {
 			ListIterator<VideoBase> iter = newestVideos.listIterator();
 			boolean added = false;
 			while (iter.hasNext()) {
 				VideoBase v = iter.next();
 				if (video.getAddedAt() > v.getAddedAt()) {
 					iter.previous();
 					iter.add(video);
 					added = true;
 					break;
 				}
 			}
 			if (!added)
 				newestVideos.addLast(video);
 			if (newestVideos.size() > maxNewestVideos)
 				newestVideos.removeLast();
 		}
 	}
 	
 	public VideoBase getVideoBase(int key) {
 		return(videoMap.get(key));
 	}
 	
 	public VideoBase getVideoById(int videoId) {
 		return(videoMap.get(mapVideoIdtoHashKey.get(videoId)));
 	}
 
 	public VideoBase getNewestVideo() {
 		if (!newestVideos.isEmpty())
 			return(newestVideos.getFirst());
 		return(null);
 	}
 
 	public List<VideoBase> getNewestVideos() {
 		return(newestVideos);
 	}
 
 	/**
 	 * @return the actors
 	 */
 	public HashSet<Actor> getActors() {
 		return actors;
 	}
 
 	/**
 	 * @param actors the actors to set
 	 */
 	public void setActors(HashSet<Actor> actors) {
 		this.actors = actors;
 	}
 
 	/**
 	 * @return the genres
 	 */
 	public HashSet<Genre> getGenres() {
 		return genres;
 	}
 
 	/**
 	 * @param genres the genres to set
 	 */
 	public void setGenres(HashSet<Genre> genres) {
 		this.genres = genres;
 	}
 
 	/**
 	 * @return the directors
 	 */
 	public HashSet<Director> getDirectors() {
 		return directors;
 	}
 
 	/**
 	 * @param directors the directors to set
 	 */
 	public void setDirectors(HashSet<Director> directors) {
 		this.directors = directors;
 	}
 
 	/**
 	 * @return the writers
 	 */
 	public HashSet<Writer> getWriters() {
 		return writers;
 	}
 
 	/**
 	 * @param writers the writers to set
 	 */
 	public void setWriters(HashSet<Writer> writers) {
 		this.writers = writers;
 	}
 
 
 }