package org.musicontroller.core;
   
   import static org.junit.Assert.assertEquals;
   import static org.junit.Assert.assertFalse;
   import static org.junit.Assert.assertNotNull;
   import static org.junit.Assert.assertNull;
   import static org.junit.Assert.assertTrue;
   
   import java.util.ArrayList;
  import java.util.Date;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Set;
  import java.util.TreeSet;
  
  import org.junit.Test;
  import org.musicontroller.security.IUser;
  import org.musicontroller.security.User;
  import org.varienaja.util.DateTools;
  
  /**
   * Unit test for the song class.
   * @author Hans Drexler
   * @version $Id: TestSong.java,v 1.1 2010/03/16 18:54:48 varienaja Exp $
   */
  public class TestSong {
  	
  	
  	/**
  	 * Test the properties of the Song class.
  	 */
  	@Test
  	public void testSong() {
  		Song song = new Song();
  		Band band = new Band();
  		song.setId(100L);
  		song.setBand(band);
  		song.setLength(100);
  		song.setName("song");
  		assertEquals(100L, song.getId());
  		assertTrue(band.equals(song.getBand()));
  		assertTrue("song".equals(song.getName()));
  		assertEquals(100L, song.getLength());
  		// Null values are allowed for String properties
  		song.setBand(null);
  		song.setName(null);
  		song.setKeywordbag(null);
  		assertNull(song.getBand());
  		assertEquals("", song.getName());
  		assertNull(song.getKeywordbag());
  	}
  	
  	/**
  	 * Tests the max 150 characters name limit
  	 */
  	@Test
  	public void testSongnameSetter() {
  		String ten = "1234567890";
  		String onehundredandfifty = ten+ten+ten+ten+ten+ten+ten+ten+ten+ten+ten+ten+ten+ten+ten; 
  		Song song = new Song();
  		song.setName(onehundredandfifty+"A");
  		assertEquals(song.getName(), onehundredandfifty);
  	}
  
  	@Test
  	public void testToString() {
  		Song song = new Song();
  		assertEquals("The representation of the empty song was incorrect.","[-1]  (0:00) [] ",song.toString());
  		song.setName(null);
  		assertEquals("The representation of the empty song was incorrect.","[-1]  (0:00) [] ",song.toString());
  		song.setName("This song has a <strange> name.");
  		assertEquals("The representation of the song was incorrect.","[-1] This song has a <strange> name. (0:00) [] ",song.toString());		
  	}
  	
  	/**
  	 * Tests adding a requested event to the song.
  	 */
  	@Test
  	public void testAddRequestedEvent() {
  		Song s = new Song();
  		IUser u = new User();
  		Event e = s.addRequestedEvent(DateTools.currentDate(), u);
  		assertNotNull("No event was created.",e);
  		assertEquals("Event type was wrong.",Event.requested,e.getEventkind());
  	}
  	
  	/**
  	 * Tests adding a skip event to the song.
  	 */
  	@Test
  	public void testAddSkippedEvent() {
  		Song s = new Song();
  		IUser u = new User();
  		Event e = s.addSkippedEvent(DateTools.currentDate(), u);
  		assertNotNull("No event was created.",e);
  		assertEquals("Event type was wrong.",Event.skipped,e.getEventkind());
  	}
  
  	/**
 	 * Tests adding a downloaded event to the song.
 	 */
 	@Test
 	public void testAddDownloadedEvent() {
 		Song s = new Song();
 		IUser u = new User();
 		Event e = s.addDownloadedEvent(DateTools.currentDate(), u);
 		assertNotNull("No event was created.",e);
 		assertEquals("Event type was wrong.",Event.downloaded,e.getEventkind());
 	}
 
 	/**
 	 * Tests adding null as an event set, which should be ignored.
 	 *
 	 */
 	@Test
 	public void testSetEventsNull() {
 		Song s = new Song();
 		assertNotNull("Event set was not initialized.",s.getEvents());
 		assertEquals("Event set was't empty initially.",0,s.getEvents().size());
 		s.addDownloadedEvent(DateTools.currentDate(), new User());
 		assertEquals("Event wasn't added.",1,s.getEvents().size());
 		s.setEvents(null);
 		assertEquals("Event set wasn't kept.",1,s.getEvents().size());
 	}
 	
 	/**
 	 * Tests the <tt>playlistSet</tt> property.
 	 * Tests setting a <tt>null</tt> as playlist set, which should be ignored.
 	 */
 	@Test
 	public void testSetPlaylists() {
 		Song s = new Song();
 		Set<Contract_PS> plset = new HashSet<Contract_PS>();
 		plset.add(new Contract_PS());
 		s.setPlaylists(plset);
 		assertEquals("Playlist set has wrong size.",1,s.getPlaylists().size());
 		s.setPlaylists(null);
 		assertEquals("Playlist set has wrong size.",1,s.getPlaylists().size());		
 	}
 	
 	/**
 	 * Tests the listing of keywords as a comma separated list.
 	 */
 	@Test
 	public void testListKeywords() {
 		Song s = new Song();
 		assertEquals("Keyword list was not empty.","",s.listKeywords());
 		Keyword kw = new Keyword();
 		kw.setName("kw1");
 		// Now try the empty keyword bag.
 		Keywordbag bag = new Keywordbag();
 		s.setKeywordbag(bag);
 		assertEquals("Keyword list was wrong.","",s.listKeywords());
 		// Then try with 1 keywoord in the bag.
 		List<Keyword> kwList = new ArrayList<Keyword>();
 		kwList.add(kw);
 		bag.setKeywords(kwList);
 		assertEquals("Keyword list was wrong.","kw1",s.listKeywords());
 		// Then try with 2 keywords in the bag.
 		Keyword kw2 = new Keyword();
 		kw2.setName("kw2");
 		kwList.add(kw2);
 		assertEquals("Keyword list was wrong.","kw1, kw2",s.listKeywords());		
 	}
 	
 	/**
 	 * Tests the listing of playlists containing the song as a comma separated list.
 	 *
 	 */
 	@Test
 	public void testListPlaylists() {
 		Song s = new Song();
 		// test with empty playlists
 		assertEquals("Playlist list was wrong.","",s.listPlaylists());
 		// test playlist contract with null playlist object. This should be ignored. 
 		Set<Contract_PS> playlistlist = new HashSet<Contract_PS>();
 		s.setPlaylists(playlistlist);
 		Contract_PS c_ps1 = new Contract_PS();
 		playlistlist.add(c_ps1);
 		assertEquals("Playlist list was wrong.","",s.listPlaylists());
 		// test with one playlist. whose title is empty.
 		Playlist pl = new Playlist();
 		c_ps1.setPlaylist(pl);
 		assertEquals("Playlist list was wrong.","",s.listPlaylists());
 		// test with one playlist. The playlist has a null name.
 		pl.setName(null);
 		assertEquals("Playlist list was wrong.","",s.listPlaylists());
 		// test with one playlist. whose title is not empty
 		pl.setName("pl");
 		assertEquals("Playlist list was wrong.","pl",s.listPlaylists());
 		// test with 2 playlists.
 		Contract_PS c_ps2 = new Contract_PS();
 		playlistlist.add(c_ps2);
 		c_ps2.setPlaylist(pl);
 		assertEquals("Playlist list was wrong.","pl, pl",s.listPlaylists());
 	}
 	
 	/**
 	 * Tests the string representation of the song length.
 	 */
 	@Test
 	public void testGetFormattedLength() {
 		Song s = new Song();
 		s.setLength(0);
 		assertEquals("Wrong length.","0:00",s.getFormattedLength());
 		s.setLength(60000);
 		assertEquals("Wrong length.","1:00",s.getFormattedLength());
 		s.setLength(11000);
 		assertEquals("Wrong length.","0:11",s.getFormattedLength());
 		s.setLength(-20000);
 		assertEquals("Wrong length.","0:20",s.getFormattedLength());
 		// This is the longest song we can record.
 		s.setLength(Integer.MAX_VALUE);
 		assertEquals("Wrong length.","35791:23",s.getFormattedLength());
 	}
 	
 	/**
 	 * Tests getting the play count.
 	 */
 	@Test
 	public void testGetPlaycount() {
 		Song s = new Song();
 		assertEquals("Wrong play count",0,s.getPlaycount(null));
 	}
 	
 	/**
 	 * Tests getting the request count.
 	 */
 	@Test
 	public void testGetRequestcount() {
 		Song s = new Song();
 		assertEquals("Wrong request count",0,s.getRequestcount(null));
 	}
 
 	/**
 	 * Tests getting the skip count.
 	 */
 	@Test
 	public void testGetSkipcount() {
 		Song s = new Song();
 		assertEquals("Wrong skip count",0,s.getSkipcount(null));
 	}
 
 	/**
 	 * Tests getting the event count.
 	 */
 	@Test
 	public void testGetEventcount() {
 		Song s = new Song();
 		assertEquals("Wrong event count",0,s.getEventcount(null,Event.played));
 		IUser u = new User();
 		Date eventdate = DateTools.encodeDate(01, 01, 2008);
 		s.addPlayedEvent(eventdate, u);
 		assertEquals("wrong event count",1,s.getEventCount(u, Event.played,DateTools.encodeDate(01, 01, 2007),null));
 		assertEquals("wrong event count",1,s.getEventCount(u, Event.played,DateTools.encodeDate(01, 01, 2007),DateTools.encodeDate(01, 01, 2009)));
 		assertEquals("wrong event count",1,s.getEventCount(u, Event.played,null,DateTools.encodeDate(01, 01, 2009)));
 	}
 	
 	/**
 	 * Test getting the date of last play.
 	 */
 	@Test
 	public void testGetLastPlay() {
 		Song s = new Song();
 		s.setId(3);
 		assertNull("Wrong last play date",s.getLastPlay(null));
 		try {
 			s.addPlayedEvent(DateTools.encodeDate(01, 04, 2005), null);
 			assertTrue("Exception expected: adding events without user should be forbidden.", false);
 		} catch (IllegalArgumentException e) {
 			//ok.
 		}
 		IUser u = new User();
 		s.addPlayedEvent(DateTools.encodeDate(01, 04, 2004), u);
 		s.addPlayedEvent(DateTools.encodeDate(01, 05, 2005), u);
 		s.addPlayedEvent(DateTools.encodeDate(01, 06, 2005), u);
 		assertEquals("wrong last play date.",DateTools.encodeDate(01, 06, 2005),s.getLastPlay(u));
 		assertEquals("wrong eventcount", 3, s.getEventcount(u, Event.played));
 		assertEquals("wrong eventcount", 0, s.getEventcount(u, Event.skipped));
 	}
 	
 	/**
 	 * Test object equality.
 	 */
 	@Test
 	public void testEquals() {
 		Song s1 = new Song();
 		Song s2 = new Song();
 		assertEquals("Should be equal.",s1,s2);
 		assertEquals("Should be equal.",s2,s1);
 		assertFalse("Should not be equal.",s1.equals(null));
 		assertFalse("Should not be equal.",s1.equals(""));
 	}
 	
 	/**
 	 * Test the Eventcount lookup-construct.
 	 */
 	@Test
 	public void testEvencountLookup() {
 		Integer[] eventkinds = new Integer[]{Event.downloaded, Event.played, 
 				Event.requested, Event.skipped, Event.unknown};
 		long userId = 20;
 		long firstEventInMillis = System.currentTimeMillis();
 		
 		User user = new User();
 		user.setId(userId);
 		
 		// We create a lot of Songs, to make sure the LRUMap of the
 		// EventCountlookup class gets full.
 		for (int i=1; i<=2*EventCountLookup.CACHESIZE; i++) {
 			Song s = new Song();
 			s.setId(i);
 			s.setName("Testsong " + i);
 			
 			//We create a Set of idCounter / 1000 Events.
 			Set<Event> events = new TreeSet<Event>();
 			for (int j=1000; j<=i; j+=1000) {
 				for (int k=0; k<eventkinds.length; k++) {
 					Event e = new Event();
 					e.setMoment(new Date(firstEventInMillis++)); //Generate unique moments.
 					e.setId(10000000*i+j);
 					e.setEventkind(eventkinds[k]);
 					e.setSong(s);
 					e.setUser(user);
 					events.add(e);
 				}
 			}
 			s.setEvents(events);
 
 			//The next statement makes sure the EventCountLookup for this Song
 			//is created. The pupularity is plays+requests+downloads-skips.
 			//Since i/1000 == plays == downloads == skips == requests,
 			//we expect 1+1+1-1 = 2 --> 2 * (i/1000) as popularity.
 			int cnt = 2*(i/1000);
 			assertEquals(s.toString(), cnt, s.getPopularity(user, null, null));
 		}
 		
 		//Now, it is time for assertions. The last CACHESIZE Songs should be
 		//contained in the EventCountLookup class. So let's query directly!
 		
 		for (int i=2*EventCountLookup.CACHESIZE; i>EventCountLookup.CACHESIZE; i--) {
 			EventCountLookup lookup = EventCountLookup.create(null, i);
 			assertNotNull(lookup);
 			for (int k=0; k<eventkinds.length; k++) {
 				if (eventkinds[k] == Event.unknown) { //Unknown eventcounts are not cached, they return 0.
 					assertEquals("Error in EventCount for song: "+i, 0, lookup.getEventCount(userId, eventkinds[k]));
 					assertEquals("Error in EventCount for song: "+i, 0, lookup.getEventCountLastYear(userId, eventkinds[k]));
 				} else {
 					assertEquals("Error in EventCount for song: "+i, i/1000, lookup.getEventCount(userId, eventkinds[k]));
 					assertEquals("Error in EventCount for song: "+i, i/1000, lookup.getEventCountLastYear(userId, eventkinds[k]));
 				}
 				assertEquals("Count should be 0 for an user that did not generate events for song: "+i, 0, lookup.getEventCountLastYear(3L, eventkinds[k]));
 				assertNull("Last play shoul be null for a user that did not generate events for song: "+i, lookup.getLastPlay(3));
 			}
 		}
 	}
 }