/**
 * The contents of this file are subject to the license and copyright
 * detailed in the LICENSE and NOTICE files at the root of the source
 * tree and available online at
 *
 * http://www.dspace.org/license/
 */
package org.dspace.content;

import org.dspace.content.factory.ContentServiceFactory;
import org.dspace.content.service.CollectionService;
import org.dspace.content.service.CommunityService;
import org.dspace.content.service.ItemService;
import org.dspace.content.service.WorkspaceItemService;
import org.dspace.core.Constants;
import mockit.NonStrictExpectations;
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import java.util.UUID;

import org.dspace.authorize.AuthorizeException;
import org.dspace.core.Context;
import org.dspace.eperson.EPerson;
import org.dspace.AbstractUnitTest;
import org.apache.log4j.Logger;
import org.dspace.eperson.factory.EPersonServiceFactory;
import org.dspace.eperson.service.EPersonService;
import org.junit.*;
import static org.junit.Assert.* ;
import static org.hamcrest.CoreMatchers.*;

/**
 * Unit Tests for class WorkspaceItem
 * @author pvillega
 */
public class WorkspaceItemTest extends AbstractUnitTest
{

    /** log4j category */
    private static final Logger log = Logger.getLogger(WorkspaceItemTest.class);

    /**
     * WorkspaceItem instance for the tests
     */
    private WorkspaceItem wi;
    private Community owningCommunity;
    private Collection collection;

    protected CommunityService communityService = ContentServiceFactory.getInstance().getCommunityService();
    protected CollectionService collectionService = ContentServiceFactory.getInstance().getCollectionService();
    protected EPersonService ePersonService = EPersonServiceFactory.getInstance().getEPersonService();
    protected ItemService itemService = ContentServiceFactory.getInstance().getItemService();
    protected WorkspaceItemService workspaceItemService = ContentServiceFactory.getInstance().getWorkspaceItemService();

    /**
     * This method will be run before every test as per @Before. It will
     * initialize resources required for the tests.
     *
     * Other methods can be annotated with @Before here or in subclasses
     * but no execution order is guaranteed
     */
    @Before
    @Override
    public void init()
    {
        super.init();
        try
        {
            //we have to create a new community in the database
            context.turnOffAuthorisationSystem();
            this.owningCommunity = communityService.create(null, context);
            this.collection = collectionService.create(context, owningCommunity);
            this.wi = workspaceItemService.create(context, collection, true);
            //we need to commit the changes so we don't block the table for testing
            context.restoreAuthSystemState();
        } catch (AuthorizeException ex)
        {
            log.error("Authorization Error in init", ex);
            fail("Authorization Error in init: " + ex.getMessage());
        }
        catch (SQLException ex)
        {
            log.error("SQL Error in init", ex);
            fail("SQL Error in init: " + ex.getMessage());
        }
    }

    /**
     * This method will be run after every test as per @After. It will
     * clean resources initialized by the @Before methods.
     *
     * Other methods can be annotated with @After here or in subclasses
     * but no execution order is guaranteed
     */
    @After
    @Override
    public void destroy()
    {
        wi = null;
        try {
            context.turnOffAuthorisationSystem();
            communityService.removeCollection(context, owningCommunity, collection);
        }
        catch (IOException ex) {
            log.error("IO Error in init", ex);
            fail("IO Error in init: " + ex.getMessage());
        }
        catch (AuthorizeException ex)
        {
            log.error("Authorization Error in init", ex);
            fail("Authorization Error in init: " + ex.getMessage());
        }
        catch (SQLException ex)
        {
            log.error("SQL Error in init", ex);
            fail("SQL Error in init: " + ex.getMessage());
        } finally {
            context.restoreAuthSystemState();
        }
        context.restoreAuthSystemState();
        super.destroy();
    }

    /**
     * Test of find method, of class WorkspaceItem.
     */
    @Test
    public void testFind() throws Exception
    {
        int id = wi.getID();
        WorkspaceItem found = workspaceItemService.find(context, id);
        assertThat("testFind 0",found,notNullValue());
        assertThat("testFind 1",found.getID(), equalTo(id));
        assertThat("testFind 2",found, equalTo(wi));
        assertThat("testFind 3",found.getCollection(),equalTo(wi.getCollection()));
    }

    /**
     * Test of create method, of class WorkspaceItem.
     */
    @Test
    public void testCreateAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow Collection ADD perms
                authorizeService.authorizeAction((Context) any, (Collection) any,
                    Constants.ADD); result = null;
        }};

        boolean template = false;
        WorkspaceItem created = null;

        template = false;
        created = workspaceItemService.create(context, collection, template);
        assertThat("testCreate 0",created,notNullValue());
        assertTrue("testCreate 1",created.getID() >= 0);
        assertThat("testCreate 2",created.getCollection(),equalTo(collection));

        template = true;
        created = workspaceItemService.create(context, collection, template);
        assertThat("testCreate 3",created,notNullValue());
        assertTrue("testCreate 4",created.getID() >= 0);
        assertThat("testCreate 5",created.getCollection(),equalTo(collection));
    }

    /**
     * Test of create method, of class WorkspaceItem.
     */
    @Test(expected=AuthorizeException.class)
    public void testCreateNoAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Disallow Collection ADD perms
                authorizeService.authorizeAction((Context) any, (Collection) any,
                    Constants.ADD); result = new AuthorizeException();
        }};

        boolean template = false;
        WorkspaceItem created = null;

        template = false;
        created = workspaceItemService.create(context, collection, template);
        fail("Exception expected");
    }

    /**
     * Test of findByEPerson method, of class WorkspaceItem.
     */
    @Test
    public void testFindByEPerson() throws Exception
    {
        EPerson ep = context.getCurrentUser();
        List<WorkspaceItem> found = workspaceItemService.findByEPerson(context, ep);
        assertThat("testFindByEPerson 0",found,notNullValue());
        assertTrue("testFindByEPerson 1",found.size() >= 1);
        boolean exists = false;
        for(WorkspaceItem w: found)
        {
            if(w.equals(wi))
            {
                exists = true;
            }
        }
        assertTrue("testFindByEPerson 2",exists);
    }

    /**
     * Test of findByCollection method, of class WorkspaceItem.
     */
    @Test
    public void testFindByCollection() throws Exception
    {
        Collection c = wi.getCollection();
        List<WorkspaceItem> found = workspaceItemService.findByCollection(context, c);
        assertThat("testFindByCollection 0",found,notNullValue());
        assertTrue("testFindByCollection 1",found.size() >= 1);
        assertThat("testFindByCollection 2",found.get(0).getID(), equalTo(wi.getID()));
        assertThat("testFindByCollection 3",found.get(0), equalTo(wi));
        assertThat("testFindByCollection 4",found.get(0).getCollection(),equalTo(wi.getCollection()));
    }

    /**
     * Test of findAll method, of class WorkspaceItem.
     */
    @Test
    public void testFindAll() throws Exception
    {
        List<WorkspaceItem> found = workspaceItemService.findAll(context);
        assertTrue("testFindAll 0",found.size() >= 1);
        boolean added = false;
        for(WorkspaceItem f: found)
        {
            assertThat("testFindAll 1",f,notNullValue());
            assertThat("testFindAll 2",f.getItem(),notNullValue());
            assertThat("testFindAll 3",f.getSubmitter(),notNullValue());
            if(f.equals(wi))
            {
                added = true;
            }
        }
        assertTrue("testFindAll 4",added);
    }

    /**
     * Test of getID method, of class WorkspaceItem.
     */
    @Test
    public void testGetID()
    {
        assertTrue("testGetID 0", wi.getID() >= 0);
    }

    /**
     * Test of getStageReached method, of class WorkspaceItem.
     */
    @Test
    public void testGetStageReached() 
    {
        assertTrue("testGetStageReached 0", wi.getStageReached() == -1);
    }

    /**
     * Test of setStageReached method, of class WorkspaceItem.
     */
    @Test
    public void testSetStageReached()
    {
        wi.setStageReached(4);
        assertTrue("testSetStageReached 0", wi.getStageReached() == 4);
    }

    /**
     * Test of getPageReached method, of class WorkspaceItem.
     */
    @Test
    public void testGetPageReached()
    {
        assertTrue("testGetPageReached 0", wi.getPageReached() == -1);
    }

    /**
     * Test of setPageReached method, of class WorkspaceItem.
     */
    @Test
    public void testSetPageReached() 
    {
        wi.setPageReached(4);
        assertTrue("testSetPageReached 0", wi.getPageReached() == 4);
    }

    /**
     * Test of update method, of class WorkspaceItem.
     */
    @Test
    public void testUpdateAuth() throws Exception
    {
		// no need to mockup the authorization as we are the same user that have
		// created the wi
        boolean pBefore = wi.isPublishedBefore();
        wi.setPublishedBefore(!pBefore);
        workspaceItemService.update(context, wi);
        context.commit();
        // force to read the data from the database
        context.uncacheEntity(wi);
        // read all our test attributes objects from the fresh session 
        // to avoid duplicate object in session issue
        wi = workspaceItemService.find(context, wi.getID());
        collection = wi.getCollection();
        owningCommunity = collection.getCommunities().get(0);
        assertTrue("testUpdate", pBefore != wi.isPublishedBefore());
    }
    
    /**
     * Test of update method, of class WorkspaceItem with no WRITE auth.
     */
    @Test(expected=AuthorizeException.class)
    public void testUpdateNoAuth() throws Exception
    {
    	new NonStrictExpectations(authorizeService.getClass())
        {{
             // Remove Item WRITE perms
        	authorizeService.authorizeActionBoolean((Context) any, (Item) any,
                    Constants.WRITE); result = false; 
                    authorizeService.authorizeAction((Context) any, (Item) any,
                     Constants.WRITE); result = new AuthorizeException();
        }};
        boolean pBefore = wi.isPublishedBefore();
        wi.setPublishedBefore(!pBefore);
        workspaceItemService.update(context, wi);
    	fail("Exception expected");
    }

    /**
     * Test of deleteAll method, of class WorkspaceItem.
     */
    @Test
    public void testDeleteAllAuth() throws Exception
    {
        int id = wi.getID();
        //we are the user that created it (same context) so we can delete
        workspaceItemService.deleteAll(context, wi);
        WorkspaceItem found = workspaceItemService.find(context, id);
        assertThat("testDeleteAllAuth 0",found,nullValue());
    }

    /**
     * Test of deleteAll method, of class WorkspaceItem.
     */
    @Test
    public void testDeleteAllNoAuth() throws Exception
    {
        //we create a new user in context so we can't delete
        EPerson old = context.getCurrentUser();
        context.turnOffAuthorisationSystem();
        context.setCurrentUser(ePersonService.create(context));
        context.restoreAuthSystemState();
        try
        {
            workspaceItemService.deleteAll(context, wi);
            fail("Exception expected");
        }
        catch(AuthorizeException ex)
        {
            context.setCurrentUser(old);
        }
    }

    /**
     * Test of deleteWrapper method, of class WorkspaceItem.
     */
    @Test
    public void testDeleteWrapperAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow Item WRITE perms
                authorizeService.authorizeAction((Context) any, (Item) any,
                    Constants.WRITE); result = null;
        }};

        UUID itemid = wi.getItem().getID();
        int id = wi.getID();
        workspaceItemService.deleteWrapper(context, wi);
        Item found = itemService.find(context, itemid);
        assertThat("testDeleteWrapperAuth 0",found,notNullValue());
        WorkspaceItem wfound = workspaceItemService.find(context, id);
        assertThat("testDeleteWrapperAuth 1",wfound,nullValue());
    }

    /**
     * Test of deleteWrapper method, of class WorkspaceItem.
     */
    @Test(expected=AuthorizeException.class)
    public void testDeleteWrapperNoAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Disallow Item WRITE perms
                authorizeService.authorizeAction((Context) any, (Item) any,
                    Constants.WRITE); result = new AuthorizeException();
        }};

        workspaceItemService.deleteWrapper(context, wi);
        fail("Exception expected");
    }

    /**
     * Test of getItem method, of class WorkspaceItem.
     */
    @Test
    public void testGetItem()
    {
        assertThat("testGetItem 0", wi.getItem(), notNullValue());
    }

    /**
     * Test of getCollection method, of class WorkspaceItem.
     */
    @Test
    public void testGetCollection() 
    {
        assertThat("testGetCollection 0", wi.getCollection(), notNullValue());
    }

    /**
     * Test of getSubmitter method, of class WorkspaceItem.
     */
    @Test
    public void testGetSubmitter() throws Exception
    {
        assertThat("testGetSubmitter 0", wi.getSubmitter(), notNullValue());
        assertThat("testGetSubmitter 1", wi.getSubmitter(), equalTo(context.getCurrentUser()));
    }

    /**
     * Test of hasMultipleFiles method, of class WorkspaceItem.
     */
    @Test
    public void testHasMultipleFiles()
    {
        assertFalse("testHasMultipleFiles 0", wi.hasMultipleFiles());
    }

    /**
     * Test of setMultipleFiles method, of class WorkspaceItem.
     */
    @Test
    public void testSetMultipleFiles()
    {
        wi.setMultipleFiles(true);
        assertTrue("testSetMultipleFiles 0", wi.hasMultipleFiles());
    }

    /**
     * Test of hasMultipleTitles method, of class WorkspaceItem.
     */
    @Test
    public void testHasMultipleTitles() 
    {
        assertFalse("testHasMultipleTitles 0", wi.hasMultipleTitles());
    }

    /**
     * Test of setMultipleTitles method, of class WorkspaceItem.
     */
    @Test
    public void testSetMultipleTitles() 
    {
        wi.setMultipleTitles(true);
        assertTrue("testSetMultipleTitles 0", wi.hasMultipleTitles());
    }

    /**
     * Test of isPublishedBefore method, of class WorkspaceItem.
     */
    @Test
    public void testIsPublishedBefore() 
    {
        assertFalse("testIsPublishedBefore 0", wi.isPublishedBefore());
    }

    /**
     * Test of setPublishedBefore method, of class WorkspaceItem.
     */
    @Test
    public void testSetPublishedBefore() 
    {
        wi.setPublishedBefore(true);
        assertTrue("testSetPublishedBefore 0", wi.isPublishedBefore());
    }

}