package org.musicontroller.test.db;
   
   import java.util.ArrayList;
   import java.util.Calendar;
   import java.util.GregorianCalendar;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Iterator;
   import java.util.List;
  import java.util.Map;
  
  import org.junit.Test;
  import static org.junit.Assert.*;
  
  import org.musicontroller.core.AIBag;
  import org.musicontroller.core.AIRelation;
  import org.musicontroller.core.Artist;
  import org.musicontroller.core.Band;
  import org.musicontroller.core.Event;
  import org.musicontroller.core.Instrument;
  import org.musicontroller.core.Keyword;
  import org.musicontroller.core.Keywordbag;
  import org.musicontroller.core.Playlist;
  import org.musicontroller.core.Song;
  import org.musicontroller.dao.BagAndKeywordUtils;
  import org.musicontroller.security.IUser;
  import org.musicontroller.test.HSQLTestCase;
  
  
  /**
   * @author Varienaja
   */
  public class DaoTest extends HSQLTestCase {
  	
  	@Test
  	public void testGetSongIds() {
  		List<Long> songids = getDao().getSongIds();
  		assertNotNull(songids);
  		assertTrue(songids.size()>0);
  	}
  	
  	@Test
  	public void testGetSongById() {
  		Song song = getDao().getSongById(TestSongId1);
  		assertNotNull(song);
  		song = getDao().getSongById(-1);
  		assertNull(song);
  	}
  	
  	@Test
  	public void testGetBandById() {
  		Band band = getDao().getBandById(TestBandId);
  		assertNotNull(band);
  		band = getDao().getBandById(-1);
  		assertNull(band);
  	}
  
  	@Test
  	public void testGetKeywordById() {
  		Keyword k = getDao().getKeywordById(TestKeywordId1);
  		assertNotNull("The test keyword should be present.",k);
  		k = getDao().getKeywordById(Long.MAX_VALUE);
  		assertNull("This keyword does not exist in the test database.",k);
  		k = getDao().getKeywordById(Long.MIN_VALUE);
  		assertNull("This keyword does not exist in the test database.",k);
  	}
  
  	@Test
  	public void testGetKeywordbagById() {
  		// There are no keyword bags in the initial test database.
  		Keywordbag kw = getDao().getKeywordBagById(1);
  		assertNull(kw);
  		// Now create a keyword bag. This will receive id 1. Retrieve it.
  		BagAndKeywordUtils.getKeywordBag("a,b");
  		kw = getDao().getKeywordBagById(1);
  		assertNotNull(kw);
  	}
  
  	@Test
  	public void testGetArtistById() {
  		Artist artist = getDao().getArtistById(TestArtistId);
  		assertNotNull(artist);
  		artist = getDao().getArtistById(-1);
  		assertNull(artist);
  	}
  
  	@Test
  	public void testGetAiBagById() {
  		// The test database contains no ai_bags objects.
  		AIBag bag = getDao().getAIBagById(1);
  		assertNull(bag);
  		// Now create a bag. This should receive id 1.
  		BagAndKeywordUtils.getAIBag(new HashSet<AIRelation>());
  		bag = getDao().getAIBagById(1);
  		assertNotNull("The new AIBag should be retrievable.",bag);
  		assertEquals("The new AIBag should be persistent, with a real database id.",1,bag.getId());
  	}
  	
  	@Test
 	public void testGetInstrumentById() {
 		Instrument instrument = getDao().getInstrumentById(TestInstrumentId);
 		assertNotNull(instrument);
 		instrument = getDao().getInstrumentById(-1);
 		assertNull(instrument);
 	}
 	
 	@Test
 	public void testGetSong() {
 		Band band = getDao().getBandById(TestBandId);
 		Song song = getDao().getSong(band, TestSongName1);
 		assertNotNull(song);
 		song = getDao().getSong(null, TestSongName1);
 		assertNull(song);
 		song = getDao().getSong(band, null);
 		assertNull(song);
 	}
 	
 	@Test
 	public void testSongsByBand() {
 		Playlist playlist = getDao().songsByBand(TestBandId);
 		assertTrue(playlist.getSongs().size()>0);
 		playlist = getDao().songsByBand(-1);
 		assertEquals(0,playlist.getSongs().size());
 	}
 	
 	@Test
 	public void testSearchBand() {
 		Band band = getDao().searchBand(TestBandName);
 		assertNotNull(band);
 		band = getDao().searchBand(null);
 		assertNull(band);
 	}
 	
 	@Test
 	public void testSearchPlaylist() {
 		Playlist playlist = getDao().songsByBand(TestBandId);
 		assertNotNull(playlist);
 		playlist.setName("test");
 		getDao().save(playlist);
 		List<Playlist> hits = getDao().searchPlaylist(playlist.getName());
 		assertNotNull(hits);
 		assertTrue(hits.size()>0);
 		assertTrue(hits.contains(playlist));
 		hits = getDao().searchPlaylist(null);
 		assertNotNull(hits);
 		assertTrue(hits.size()==0);
 	}
 	
 	/**
 	 * Selects all songs joined with their performing bands.
 	 * The number of results should equal the number of songs.
 	 */
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testBandsListerHql() {
 		IUser user = getDao().getUserById(persistentUserId);
 		Calendar lastYear = new GregorianCalendar();
 		lastYear.add(Calendar.YEAR,-1);
 
 		String hql = "from Band b";
 		List result = getDao().search(hql, null, 0);
 		int totalBands = result.size();
 		
 		hql = "from Song s join s.band b left outer join s.events ev" +
 				" with ev.moment>:startdate and ev.eventkind=:kind and ev.user.id=:userid";
 		Map<String,Object> params = new HashMap<String,Object>();
 		params.put("userid", user.getId());
 		params.put("kind", Event.played);
 		params.put("startdate",lastYear.getTime());
 
 		result = getDao().search(hql, params, 0);
 		System.out.println("list size: "+result.size()+", total bands: "+totalBands);
 		assertEquals("All songs should be included in the result",7,result.size());
 	}
 	
 	@Test
 	public void testListBands() {
 		List<Object[]> bandInfos = getDao().listBands(getDao().getUserById(persistentUserId));
 		assertNotNull("The list of band information should not be null.",bandInfos);
 		assertNotNull(bandInfos);
 		assertTrue(bandInfos.size()>0);
 		bandInfos = getDao().listBands(null);
 		assertNotNull("The list for the NULL user should not be null.",bandInfos);
 		assertEquals("The list of band information should contain 3 entries",3,bandInfos.size());
 		Iterator<Object[]> it = bandInfos.iterator();
 		while(it.hasNext()) {
 			Object[] elt = it.next();
 			// The first element must be long, the second String and the third an integer.
 			@SuppressWarnings("unused")
 			Long e1 = (Long) elt[0];
 			@SuppressWarnings("unused")
 			String e2 = (String) elt[1];
 			@SuppressWarnings("unused")
 			Long e3 = (Long)elt[2];
 		}
 	}
 
 	@SuppressWarnings("unchecked")
 	@Test
 	public void testListKeywords() {
 		IUser user = getDao().getUserById(persistentUserId);
 		// Construct a keyword bag on song 1.
 		Song s = getDao().getSongById(TestSongId1);
 		Keyword kw = getDao().searchKeyword("Rock");
 		assertNotNull("The Rock keyword should exist.",kw);
 		BagAndKeywordUtils.addKeywordToSong(s, kw);
 		getDao().save(s);
 				
 		List results = getDao().search("from Keywordbag kwb", null, 0);
 		System.out.println("There are "+results.size()+" keyword bags.");
 		assertEquals("There should be one keyword bag now.",1,results.size());
 				
 		// Construct a keyword bag on song 2, containing two keywords..
 		Song s2 = getDao().getSongById(TestSongId2);
 		Keyword kw2 = getDao().searchKeyword("Reggae");
 		assertNotNull("Test song 2 should exist.",s2);
 		assertNotNull("The Reggae keyword should exist.",kw2);
 		BagAndKeywordUtils.addKeywordToSong(s2, kw);
 		BagAndKeywordUtils.addKeywordToSong(s2, kw2);
 		getDao().save(s);
 		
 		List<Object[]> result = getDao().listKeywords(user, null);
 		assertNotNull("The result should not be null.",result);
 		assertEquals("All Keywords existing in the keyword bag (Rock, Reggae) should be in the list.",2,result.size());
 
 		// filter the result on the keyword bag having only "Rock" in it. The result should
 		// contain just one result, for Rock.
 		Keywordbag filter = s.getKeywordbag();
 		List<Keywordbag> filterList = new ArrayList<Keywordbag>();
 		filterList.add(filter);
 		result = getDao().listKeywords(user, filterList);
 		assertNotNull("The result should not be null.",result);
 		assertEquals("Only Keywords existing in the filter bag (Rock) should be in the list.",1,result.size());		
 	}
 	
 	@Test
 	public void testListKeywordsbags() {
 		List<Keyword> param = new ArrayList<Keyword>();
 		
 		// Construct a keyword bag on song 1.
 		Song s = getDao().getSongById(TestSongId1);
 		Keyword kw = getDao().searchKeyword("Rock");
 		assertNotNull("The Rock keyword should exist.",kw);
 		BagAndKeywordUtils.addKeywordToSong(s, kw);
 		getDao().save(s);
 		Keywordbag withoutSoul = s.getKeywordbag();
 		param.add(kw);
 		List<Keywordbag> result = getDao().listKeywordsBags(param);
 		assertNotNull("The result should contain the keyword bag of song 1",result);
 		assertEquals("The result should contain the keyword bag of song 1",1,result.size());
 		
 		// Assign another keyword "Soul" to the song. Ask for a list of all keyword bags
 		// containing the second keyword. The keyword bag not including "Soul" should not
 		// be in the result.
 		Keyword kw2 = getDao().searchKeyword("Soul");
 		assertNotNull("The Soul keyword should be present in the test database!", kw2);
 		BagAndKeywordUtils.addKeywordToSong(s, kw2);
 		getDao().save(s);
 		
 		param.clear();
 		param.add(kw2);
 		result = getDao().listKeywordsBags(param);
 		assertTrue("The keyword bag of song should be included.",result.contains(s.getKeywordbag()));
 		assertFalse("The keyword bag not containing 'Soul' should not be included.", result.contains(withoutSoul));
 
 		result = getDao().listKeywordsBags(null);
 		assertNull("The result should be null if the parameter is null.",result);
 		result = getDao().listKeywordsBags(new ArrayList<Keyword>());
 		assertNull("The result should be null if the parameter is empty.",result);		
 	}
 	
 	@Test
 	public void testSearchKeyword() {
 		Keyword rock = getDao().searchKeyword("rock");
 		Keyword Rock = getDao().searchKeyword("Rock   ");
 		assertNotNull(rock);
 		assertNotNull(Rock);
 		assertEquals(rock, Rock);
 		rock = getDao().searchKeyword(null);
 		assertNull(rock);
 	}
 
 	@Test
 	public void testSearchArtist() {
 		Artist artist = new Artist();
 		artist.setFirstname(null);
 		artist.setLastname("Asheton");
 		getDao().save(artist);
 		Artist found = getDao().searchArtist(null, "Asheton");
 		assertNotNull(found);
 		assertEquals(artist,found);
 	}
 	
 	@Test
 	public void testMergePlaylists() {
 		getDao().mergePlaylists(null, null);
 	}	
 	
 	@Test
 	public void testDeleteArtist() {
 		Artist artist = new Artist();
 		artist.setFirstname(null);
 		artist.setLastname("Asheton");
 		getDao().save(artist);
 		long artid = artist.getId();
 		// Delete the artist.
 		getDao().deleteArtist(artist);
 		// The artist should be gone now.
 		artist = getDao().getArtistById(artid);
 		assertNull("The artist should not exist anymore.",artist);
 		getDao().deleteArtist(null);
 	}
 	
 	@Test
 	public void testDeleteAiBag() {
 		AIBag bag = BagAndKeywordUtils.getAIBag(BagAndKeywordUtils.createRelations("Hans", "Drexler", getDao().getBandById(TestBandId), "a,b"));
 		long bagid = bag.getId();
 		assertNotNull("An Ai bag should have been returned.",bag);
 		assertTrue("The ai bag should be persistent",bagid>0);
 		// Delete the bag.
 		getDao().deleteAiBag(bag);
 		// The artist should be gone now.
 		bag = getDao().getAIBagById(bagid);
 		assertNull("The ai bag should not exist anymore.",bag);
 		getDao().deleteAiBag(null);
 	}
 
 }