package labp2.lab09;


import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.util.Iterator;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;


/**
 * Testes para {@link Organizador} de {@link Artigo}s.
 */
public class OrganizadorGenericoTest {

	private OrganizadorGenerico organizadorGenerico;

	@Before
	public void setUp() throws Exception {
		organizadorGenerico = new OrganizadorGenerico();
	}

	@After
	public void tearDown() throws Exception {
		organizadorGenerico = null;
	}

	@Test
	public void testAdd() throws Exception {
		assertEquals(0, organizadorGenerico.size());
		assertTrue(organizadorGenerico.add(new Artigo("Labs of the world, unite!!!")));
		assertEquals(1, organizadorGenerico.size());
	}

	@Test(expected=Exception.class)
	public void testAddNull() throws Exception {
		organizadorGenerico.add(null);
	}

	@Test
	public void testAddMesmoArtigo() throws Exception {
		assertTrue(organizadorGenerico.add(new Artigo("Impossibility of Distributed Consensus with One Faulty Process")));
		assertFalse(organizadorGenerico.add(new Artigo("Impossibility of Distributed Consensus with One Faulty Process")));
		assertEquals(1, organizadorGenerico.size());
	}

	@Test
	public void testTake() throws Exception {
		Artigo primeiro = new Artigo("Finding Bugs is Easy");
		Artigo segundo = new Artigo("Structured Programming with go to Statements");
		assertTrue(organizadorGenerico.add(primeiro));
		assertTrue(organizadorGenerico.add(segundo));
		assertEquals(primeiro, organizadorGenerico.take());
		assertEquals(segundo, organizadorGenerico.take());
	}

	@Test(expected=Exception.class)
	public void testTakeDeOrganizadorVazio() throws Exception {
		organizadorGenerico.take();
	}

	@Test
	public void testSize() {
		assertEquals(0, organizadorGenerico.size());
		try {
			organizadorGenerico.take();
			fail("Deveria ter lançado exceção. Organizador vazio!");
		} catch (Exception e) {}
		assertEquals(0, organizadorGenerico.size());
	}

	@Test
	public void testContains() throws Exception {
		Artigo adicionado = new Artigo("A large scale fault-tolerant grid information service");
		Artigo naoAdicionado = new Artigo("Unreliable Failure Detectors for Reliable Distributed  Systems");
		assertTrue(organizadorGenerico.add(adicionado));

		assertTrue(organizadorGenerico.contains(adicionado));
		assertFalse(organizadorGenerico.contains(naoAdicionado));
		assertEquals(adicionado, organizadorGenerico.take());
		assertFalse(organizadorGenerico.contains(adicionado));
	}

	@Test(expected=Exception.class)
	public void testContainsNull() throws Exception {
		organizadorGenerico.contains(null);
	}

	@Test
	public void testList() throws Exception {
		//assertTrue(organizador.list().isEmpty());

		Artigo primeiro = new Artigo("File system usage in Windows NT 4.0");
		Artigo segundo = new Artigo("Folksonomy as a Complex Network");

		assertTrue(organizadorGenerico.add(primeiro));
		assertEquals(primeiro.toString(), organizadorGenerico.list());
		assertTrue(organizadorGenerico.add(segundo));
		assertEquals(primeiro.toString()+ "\n" + segundo.toString(), organizadorGenerico.list());
		assertEquals(primeiro, organizadorGenerico.take());
		assertEquals(segundo.toString(), organizadorGenerico.list());
	}

	@Test
	public void testGetPosition() throws Exception {
		Artigo primeiro = new Artigo("File system usage in Windows NT 4.0");
		assertTrue(organizadorGenerico.add(primeiro));
		assertEquals(0, organizadorGenerico.getPosition(primeiro));
		Artigo segundo = new Artigo("Folksonomy as a Complex Network");
		assertTrue(organizadorGenerico.add(segundo));
		assertEquals(1, organizadorGenerico.getPosition(segundo));
		assertEquals(primeiro, organizadorGenerico.take());
		assertEquals(0, organizadorGenerico.getPosition(segundo));
	}

	@Test(expected=Exception.class)
	public void testGetPositionDeNull() throws Exception {
		organizadorGenerico.getPosition(null);
	}

	@Test
	public void testPostpone() throws Exception {
		Artigo primeiro = new Artigo("File system usage in Windows NT 4.0");
		Artigo segundo = new Artigo("Folksonomy as a Complex Network");

		assertTrue(organizadorGenerico.add(primeiro));
		assertTrue(organizadorGenerico.add(segundo));
		assertEquals(0, organizadorGenerico.getPosition(primeiro));
		assertEquals(1, organizadorGenerico.getPosition(segundo));

		assertEquals(2, organizadorGenerico.size());
		assertTrue(organizadorGenerico.postpone(primeiro));
		assertEquals(2, organizadorGenerico.size());

		assertEquals(1, organizadorGenerico.getPosition(primeiro));
		assertEquals(0, organizadorGenerico.getPosition(segundo));

		assertFalse(organizadorGenerico.postpone(primeiro));
	}

	@Test(expected=Exception.class)
	public void testPostponeNull() throws Exception {
		organizadorGenerico.postpone(null);
	}

	@Test(expected=Exception.class)
	public void testPostponeArtigoInexistente() throws Exception {
		organizadorGenerico.postpone(new Artigo("File system usage in Windows NT 4.0"));
	}

	@Test
	public void testGetHistory() throws Exception {
		assertFalse(organizadorGenerico.getHistory().hasNext());
		Artigo artigo = new Artigo("File system usage in Windows NT 4.0");
		assertTrue(organizadorGenerico.add(artigo));
		assertEquals(artigo, organizadorGenerico.take());
		Iterator<Artigo> history = organizadorGenerico.getHistory();
		Iterator<Artigo> outroHistory = organizadorGenerico.getHistory();
		assertTrue(history.hasNext());
		assertTrue(outroHistory.hasNext());
		assertEquals(artigo, history.next());
		assertEquals(artigo, outroHistory.next());
		assertFalse(history.hasNext());
		assertFalse(outroHistory.hasNext());
	}

	@Test
	public void testCleanHistory() throws Exception {
		assertFalse(organizadorGenerico.getHistory().hasNext());

		Artigo primeiro = new Artigo("Labs of the world, unite!!!");
		Artigo segundo = new Artigo("Finding Bugs is Easy");
		Artigo terceiro = new Artigo("Structured Programming with go to Statements");

		assertTrue(organizadorGenerico.add(primeiro));
		assertTrue(organizadorGenerico.add(segundo));
		assertTrue(organizadorGenerico.add(terceiro));

		assertFalse(organizadorGenerico.getHistory().hasNext());

		assertNotNull(organizadorGenerico.take());

		Iterator<Artigo> history = organizadorGenerico.getHistory();
		assertTrue(history.hasNext());
		assertEquals(primeiro, history.next());

		assertNotNull(organizadorGenerico.take());
		assertNotNull(organizadorGenerico.take());

		history = organizadorGenerico.getHistory();
		assertEquals(primeiro, history.next());
		assertEquals(segundo, history.next());
		assertEquals(terceiro, history.next());
	}

	@Test
	public void testIsInHistory() throws Exception{

		Artigo primeiro = new Artigo("Impossibility of Distributed Consensus with One Faulty Process");
		Artigo segundo = new Artigo("A large scale fault-tolerant grid information service");
		Artigo naoAdicionado = new Artigo("Unreliable Failure Detectors for Reliable Distributed  Systems");

		assertTrue(organizadorGenerico.add(primeiro));
		assertTrue(organizadorGenerico.add(segundo));

		assertFalse(organizadorGenerico.isInHistory(primeiro));
		assertFalse(organizadorGenerico.isInHistory(segundo));
		assertFalse(organizadorGenerico.isInHistory(naoAdicionado));

		assertEquals(primeiro, organizadorGenerico.take());

		assertTrue(organizadorGenerico.isInHistory(primeiro));
		assertFalse(organizadorGenerico.isInHistory(segundo));
		assertFalse(organizadorGenerico.isInHistory(naoAdicionado));

		organizadorGenerico.cleanHistory();

		assertFalse(organizadorGenerico.isInHistory(primeiro));
		assertFalse(organizadorGenerico.isInHistory(segundo));
		assertFalse(organizadorGenerico.isInHistory(naoAdicionado));
	}

	@Test(expected=Exception.class)
	public void testIsInHistoryWithNull() throws Exception{
		organizadorGenerico.isInHistory(null);
	}

}