package org.musicontroller.core;
   
   import java.util.Date;
   import java.util.HashMap;
   import java.util.Map;
   import java.util.Set;
   
   import org.varienaja.util.DateTools;
   import org.varienaja.util.LRUMap;
  
  /**
   * <p>A class for quick eventcount lookup. Songs can have any number of Events.
   * Counting Events, which happens a lot in MusiController, is relatively slow.
   * Events are lazily loaded by Hibernate, thus a call to getEvents() causes an
   * additional DB-access. Caching Events would be a solution, but is not very
   * realistic, because of the sheer amount of them. Since we're mostly interested
   * in counts, this class helps us.</p> 
   * 
   * <p>The EventCountLookup takes up only 8 integers and a Date of memory per
   * Song and User. Therefore, caching makes sense for this object. This class
   * contains a LRU-list, to which all lookup-tables are added.</p> 
   * @author Varienaja
   */
  public class EventCountLookup {
  	protected final static int CACHESIZE = 10000;
  	private static Map<Long, EventCountLookup> CACHE = new LRUMap<Long, EventCountLookup>("EventCountLookup",CACHESIZE);
  	private Map<Long,InternalLookup> _perUserLookupTable;
  	private Date _expiryDate;
  
  	/**
  	 * A per user Eventcount-lookuptable.
  	 */
  	class InternalLookup {
  		int _playCount;
  		int _skipCount;
  		int _downloadCount;
  		int _requestCount;
  		int _playCountLastYear;
  		int _skipCountLastYear;
  		int _downloadCountLastYear;
  		int _requestCountLastYear;
  		Date _lastPlay;
  
  		/**
  		 * Creates a new Lookup-object from a Set of Events.
  		 * @param events The Events.
  		 */
  		public InternalLookup(Set<Event> events, Long userid) {
  			for (Event event : events) {
  				if (event.getUser()!=null && userid.equals(event.getUser().getId())) {
  					addEvent(event);
  				}
  			}
  		}
  
  		/**
  		 * Creates a new Lookup-object from a single Event.
  		 * @param event The Event.
  		 */
  		public InternalLookup(Event event) {
  			addEvent(event);
  		}
  
  		/**
  		 * Adds an Event to the lookup-table. All counters are updated.
  		 * @param event The Event to be added.
  		 */
  		public void addEvent(Event event) {
  			Date lastYear = DateTools.lastYear();
  			switch (event.getEventkind()) {
  				case Event.played : 
  					_playCount++;
  					if (_lastPlay==null || event.getMoment().after(_lastPlay)) {
  						_lastPlay = event.getMoment();
  					}
  					break;
  				case Event.downloaded : _downloadCount++; break;
  				case Event.requested : _requestCount++; break;
  				case Event.skipped : _skipCount++; break;
  				default : ; //Do nothing.
  			}
  			
  			if (event.getMoment()!=null && event.getMoment().after(lastYear)) {
  				switch (event.getEventkind()) {
  					case Event.played : _playCountLastYear++; break;
  					case Event.downloaded : _downloadCountLastYear++; break;
  					case Event.requested : _requestCountLastYear++; break;
  					case Event.skipped : _skipCountLastYear++; break;
  				default : ; //Do nothing.
  				}
  			}
  		}
  	}
  	
  	/**
  	 * Creates a new Lookup-object from a Set of Events.
  	 * @param events The Events.
  	 */
  	private EventCountLookup(Set<Event> events, long songid) {
 		Date lastYear = DateTools.lastYear();
 		_perUserLookupTable = new HashMap<Long,InternalLookup>();
 		for (Event event : events) {
 			if (event.getUser()!=null) {
 				long userid = event.getUser().getId();
 				if (_perUserLookupTable.get(userid)==null) {
 					_perUserLookupTable.put(userid, new InternalLookup(events, userid));
 				}
 				
 				if (event.getMoment().after(lastYear)) {
 					//Set the expirydate. If we find the first Event after 'lastYear',
 					//the expirydate is set to 'now'+Moment-lastYear.
 					if (_expiryDate == null) {
 						long now = DateTools.currentDate().getTime();
 						long moment = event.getMoment().getTime();
 						long lastYr = lastYear.getTime();
 						_expiryDate = new Date(now+moment-lastYr);
 					}
 				}
 			}
 		}
 	}
 	
 	/**
 	 * Factory method, which returns an EventCountLookup object. When a cached
 	 * object is found, it is returned, otherwise a new object is created and
 	 * added to the cache.
 	 * @param events The Set of Events, for the Song. (Only accessed when a new
 	 *               EventCountLookup-object must be created. When a cached
 	 *               object is found, the Events are not touched, so that they
 	 *               can stay uninitialized when they were lazily loaded.)
 	 * @param songid The id of the Song.
 	 * @return An initialized EventCountLookup-object.
 	 */
 	public static EventCountLookup create(Set<Event> events, long songid) {
 		EventCountLookup cached = CACHE.get(songid);
 		// If we do not have a cached element OR we have a cached element, but
 		// it has expired, we build a new lookup-table.
 		if (cached==null || (cached._expiryDate!=null && cached._expiryDate.before(new Date()))) {
 			EventCountLookup result = new EventCountLookup(events, songid);
 			CACHE.put(songid, result);
 			return result;
 		} else {
 			return cached;
 		}
 	}
 	
 	/**
 	 * Updates this EventCountLookup object with a new Event.
 	 * @param event The new Event.
 	 */
 	public void addEvent(Event event) {
 		long userid = event.getUser().getId();
 		InternalLookup lookup = _perUserLookupTable.get(userid);
 		if (lookup==null) {
 			_perUserLookupTable.put(userid, new InternalLookup(event));
 		} else {
 			lookup.addEvent(event);
 		}
 	}
 
 	/**
 	 * Returns the amount of Events of a certain type.
 	 * @param userid The user to look these Events up for.
 	 * @param kind The type of Events to look the count up for.
 	 * @return The amount of Events.
 	 */
 	public int getEventCount(long userid, int kind) {
 		InternalLookup lookup = _perUserLookupTable.get(userid);
 		if (lookup==null) {
 			return 0;
 		}
 		switch (kind) {
 			case Event.played : return lookup._playCount;
 			case Event.downloaded : return lookup._downloadCount;
 			case Event.requested : return lookup._requestCount;
 			case Event.skipped : return lookup._skipCount;
 			default : return 0;
 		}
 	}
 
 	/**
 	 * Returns the amount of Events of a certain type, which took place in the
 	 * last year.
 	 * @param userid The user to look these Events up for.
 	 * @param kind The type of Events to look the count up for.
 	 * @return The amount of Events.
 	 */
 	public int getEventCountLastYear(long userid, int kind) {
 		InternalLookup lookup = _perUserLookupTable.get(userid);
 		if (lookup==null) {
 			return 0;
 		}
 		switch (kind) {
 			case Event.played : return lookup._playCountLastYear;
 			case Event.downloaded : return lookup._downloadCountLastYear;
 			case Event.requested : return lookup._requestCountLastYear;
 			case Event.skipped : return lookup._skipCountLastYear;
 			default : return 0;
 		}
 	}
 
 	/**
 	 * Looks up the Date of the latest Play-Event.
 	 * @param userid The user to look this Date up for.
 	 * @return The Date when this User plays this song for the last time. ( Or 
 	 *         null when never played.)
 	 */
 	public Date getLastPlay(long userid) {
 		InternalLookup lookup = _perUserLookupTable.get(userid);
 		if (lookup==null) {
 			return null;
 		}
 		return lookup._lastPlay;
 	}
 
 }