/**
 * 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 static org.hamcrest.CoreMatchers.equalTo;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.nullValue;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.Assert.assertTrue;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.SQLException;
import java.util.UUID;

import org.dspace.AbstractIntegrationTest;
import org.dspace.authorize.AuthorizeException;
import org.dspace.content.factory.ContentServiceFactory;
import org.dspace.content.service.BitstreamService;
import org.dspace.content.service.BundleService;
import org.dspace.content.service.CollectionService;
import org.dspace.content.service.CommunityService;
import org.dspace.content.service.InstallItemService;
import org.dspace.content.service.ItemService;
import org.dspace.content.service.WorkspaceItemService;
import org.dspace.eperson.EPerson;
import org.dspace.eperson.Group;
import org.dspace.eperson.factory.EPersonServiceFactory;
import org.dspace.eperson.service.EPersonService;
import org.dspace.eperson.service.GroupService;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

/**
 * This is an integration test to ensure collections and communities interact properly.
 *
 * The code below is attached as an example.
 *
 * @author pvillega
 * @author tdonohue
 */
public class ITCommunityCollection extends AbstractIntegrationTest {
    protected CommunityService communityService = ContentServiceFactory.getInstance().getCommunityService();
    protected CollectionService collectionService = ContentServiceFactory.getInstance().getCollectionService();
    protected ItemService itemService = ContentServiceFactory.getInstance().getItemService();
    protected InstallItemService installItemService = ContentServiceFactory.getInstance().getInstallItemService();
    protected WorkspaceItemService workspaceItemService = ContentServiceFactory.getInstance().getWorkspaceItemService();
    protected EPersonService ePersonService = EPersonServiceFactory.getInstance().getEPersonService();
    protected GroupService groupService = EPersonServiceFactory.getInstance().getGroupService();
    protected BundleService bundleService = ContentServiceFactory.getInstance().getBundleService();
    protected BitstreamService bitstreamService = ContentServiceFactory.getInstance().getBitstreamService();

    /**
     * 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();
    }

    /**
     * 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() {
        super.destroy();
    }

    /**
     * Tests the creation of a community collection tree
     */
    @Test
    public void testCreateTree() throws SQLException, AuthorizeException, IOException {
        //we create the structure
        context.turnOffAuthorisationSystem();
        Community parent = communityService.create(null, context);
        Community child1 = communityService.create(parent, context);

        Collection col1 = collectionService.create(context, child1);
        Collection col2 = collectionService.create(context, child1);

        context.restoreAuthSystemState();

        //verify it works as expected
        assertThat("testCreateTree 0", parent.getParentCommunities().size(), is(0));
        assertThat("testCreateTree 1", child1.getParentCommunities().get(0), equalTo(parent));
        assertThat("testCreateTree 2", collectionService.getParentObject(context, col1), equalTo(child1));
        assertThat("testCreateTree 3", collectionService.getParentObject(context, col2), equalTo(child1));

        context.turnOffAuthorisationSystem();
        communityService.delete(context, parent);
    }

    /**
     * Tests the creation of items in a community/collection tree
     */
    @Test
    public void testCreateItems() throws SQLException, AuthorizeException, IOException {
        //we create the structure
        context.turnOffAuthorisationSystem();
        Community parent = communityService.create(null, context);
        Community child1 = communityService.create(parent, context);

        Collection col1 = collectionService.create(context, child1);
        Collection col2 = collectionService.create(context, child1);

        Item item1 = installItemService.installItem(context, workspaceItemService.create(context, col1, false));
        Item item2 = installItemService.installItem(context, workspaceItemService.create(context, col2, false));

        context.restoreAuthSystemState();

        //verify it works as expected
        assertThat("testCreateItems 0", itemService.getParentObject(context, item1), equalTo(col1));
        assertThat("testCreateItems 1", itemService.getParentObject(context, item2), equalTo(col2));

        context.turnOffAuthorisationSystem();
        communityService.delete(context, parent);
    }

    /**
     * Tests that count items works as expected
     * NOTE: Counts are currently expensive (take a while)
     */
    @Test
    public void testCountItems() throws SQLException, AuthorizeException, IOException {
        int items_per_collection = 2;

        //we create the structure
        context.turnOffAuthorisationSystem();
        Community parentCom = communityService.create(null, context);
        Community childCom = communityService.create(parentCom, context);

        Collection col1 = collectionService.create(context, childCom);
        Collection col2 = collectionService.create(context, childCom);

        // Add same number of items to each collection
        for (int count = 0; count < items_per_collection; count++) {
            installItemService.installItem(context, workspaceItemService.create(context, col1, false));
            installItemService.installItem(context, workspaceItemService.create(context, col2, false));
        }

        // Finally, let's throw in a small wrench and add a mapped item
        // Add it to collection 1
        Item item3 = installItemService.installItem(context, workspaceItemService.create(context, col1, false));
        // Map it into collection 2
        collectionService.addItem(context, col2, item3);

        // Our total number of items should be
        int totalitems = items_per_collection * 2 + 1;
        // Our collection counts should be
        int collTotalItems = items_per_collection + 1;

        context.restoreAuthSystemState();

        //verify it works as expected
        assertThat("testCountItems 0", itemService.countItems(context, col1), equalTo(collTotalItems));
        assertThat("testCountItems 1", itemService.countItems(context, col2), equalTo(collTotalItems));
        assertThat("testCountItems 2", itemService.countItems(context, childCom), equalTo(totalitems));
        assertThat("testCountItems 3", itemService.countItems(context, parentCom), equalTo(totalitems));

        context.turnOffAuthorisationSystem();
        communityService.delete(context, parentCom);
    }

    /**
     * Tests that ensure Community Admin deletion permissions are being properly
     * inherited to all objects in the Community hierarchy.
     */
    @Test
    public void testCommunityAdminDeletions() throws SQLException, AuthorizeException, IOException {
        //Turn off auth while we create the EPerson and structure
        context.turnOffAuthorisationSystem();

        // Create our Community Admin
        EPerson commAdmin = ePersonService.create(context);
        commAdmin.setEmail("comm-admin@dspace.org");
        ePersonService.update(context, commAdmin);

        // Create our Top-Level Community and add the user as an Administrator of that community
        Community parentCom = communityService.create(null, context);

        Group adminGroup = communityService.createAdministrators(context, parentCom);
        groupService.addMember(context, adminGroup, commAdmin);
        groupService.update(context, adminGroup);

        // Create a hierachy of sub-Communities and Collections and Items.
        Community child = communityService.createSubcommunity(context, parentCom);
        Community child2 = communityService.createSubcommunity(context, parentCom);
        Community child3 = communityService.createSubcommunity(context, parentCom);
        Community grandchild = communityService.createSubcommunity(context, child);
        Collection childCol = collectionService.create(context, child);
        Collection grandchildCol = collectionService.create(context, grandchild);
        // Create two separate items
        WorkspaceItem wsItem = workspaceItemService.create(context, childCol, false);
        Item item = installItemService.installItem(context, wsItem);
        wsItem = workspaceItemService.create(context, childCol, false);
        Item item2 = installItemService.installItem(context, wsItem);
        // Create a bitstream for one item
        File f = new File(testProps.get("test.bitstream").toString());
        Bitstream bitstream = itemService.createSingleBitstream(context, new FileInputStream(f), item);

        // Done creating the objects. Turn auth system back on
        context.restoreAuthSystemState();

        // Set the Community Admin as our current user
        context.setCurrentUser(commAdmin);

        // Test deletion of single Bitstream as a Community Admin (delete just flags as deleted)
        bitstreamService.delete(context, bitstream);
        assertTrue("Community Admin unable to flag Bitstream as deleted",
                   bitstream.isDeleted());
        // NOTE: A Community Admin CANNOT "expunge" a Bitstream, as delete() removes all their permissions

        // Test deletion of single Item as a Community Admin
        UUID itemId = item2.getID();
        itemService.delete(context, item2);
        assertThat("Community Admin unable to delete sub-Item",
                   itemService.find(context, itemId), nullValue());

        // Test deletion of single Collection as a Community Admin
        UUID collId = grandchildCol.getID();
        collectionService.delete(context, grandchildCol);
        assertThat("Community Admin unable to delete sub-Collection",
                   collectionService.find(context, collId), nullValue());

        // Test deletion of single Sub-Community as a Community Admin
        UUID commId = child2.getID();
        communityService.delete(context, child2);
        assertThat("Community Admin unable to delete sub-Community",
                   communityService.find(context, commId), nullValue());

        // Test deletion of single Sub-Community with own admin group
        communityService.createAdministrators(context, child3);
        commId = child3.getID();
        communityService.delete(context, child3);
        assertThat("Community Admin unable to delete sub-Community",
                communityService.find(context, commId), nullValue());

        // Test deletion of Sub-Community Hierarchy as a Community Admin
        commId = child.getID();
        collId = childCol.getID();
        itemId = item.getID();
        communityService.delete(context, child);
        assertThat("Community Admin unable to delete sub-Community in hierarchy",
                   communityService.find(context, commId), nullValue());
        assertThat("Community Admin unable to delete sub-Collection in hierarchy",
                   collectionService.find(context, collId), nullValue());
        assertThat("Community Admin unable to delete sub-Item in hierarchy",
                   itemService.find(context, itemId), nullValue());
    }

    /**
     * Tests that ensure Collection Admin deletion permissions are being properly
     * inherited to all objects in the Collection hierarchy.
     */
    @Test
    public void testCollectionAdminDeletions() throws SQLException, AuthorizeException, IOException {
        //Turn off auth while we create the EPerson and structure
        context.turnOffAuthorisationSystem();

        // Create our Collection Admin
        EPerson collAdmin = ePersonService.create(context);
        collAdmin.setEmail("coll-admin@dspace.org");
        ePersonService.update(context, collAdmin);

        // Create our Collection and add the user as an Administrator of that collection
        Community parentCom = communityService.create(null, context);
        Collection collection = collectionService.create(context, parentCom);

        Group adminGroup = collectionService.createAdministrators(context, collection);
        groupService.addMember(context, adminGroup, collAdmin);
        groupService.update(context, adminGroup);

        // Create an item in this Collection
        WorkspaceItem wsItem = workspaceItemService.create(context, collection, false);
        Item item = installItemService.installItem(context, wsItem);
        // Create two bundles in this item
        Bundle bundle = bundleService.create(context, item, "Bundle1");
        Bundle bundle2 = bundleService.create(context, item, "Bundle2");
        // Create two bitstreams, one in each bundle
        File f = new File(testProps.get("test.bitstream").toString());
        Bitstream bitstream = itemService.createSingleBitstream(context, new FileInputStream(f), item, "Bundle1");
        Bitstream bitstream2 = itemService.createSingleBitstream(context, new FileInputStream(f), item, "Bundle2");
        // Done creating the objects. Turn auth system back on
        context.restoreAuthSystemState();

        // Set the Collection Admin as our current user
        context.setCurrentUser(collAdmin);

        // Test deletion of single Bitstream as a Collection Admin (delete just flags as deleted)
        bitstreamService.delete(context, bitstream2);
        assertTrue("Collection Admin unable to flag Bitstream as deleted",
                   bitstream2.isDeleted());
        // NOTE: A Collection Admin CANNOT "expunge" a Bitstream, as delete() removes all their permissions

        // Test deletion of single Bundle as a Collection Admin
        UUID bundleId = bundle2.getID();
        bundleService.delete(context, bundle2);
        assertThat("Collection Admin unable to delete Bundle",
                   bundleService.find(context, bundleId), nullValue());

        // Test deletion of single Item as a Collection Admin
        UUID itemId = item.getID();
        bundleId = bundle.getID();
        itemService.delete(context, item);
        assertThat("Collection Admin unable to delete sub-Item",
                   itemService.find(context, itemId), nullValue());
        assertThat("Collection Admin unable to delete sub-Bundle",
                   bundleService.find(context, bundleId), nullValue());
        assertTrue("Collection Admin unable to flag sub-Bitstream as deleted",
                   bitstream.isDeleted());
    }
}
