/**
 * 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 mockit.NonStrictExpectations;
import org.apache.log4j.Logger;
import org.dspace.AbstractUnitTest;
import org.dspace.authorize.AuthorizeException;
import org.dspace.content.factory.ContentServiceFactory;
import org.dspace.content.service.MetadataFieldService;
import org.dspace.content.service.MetadataSchemaService;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import java.sql.SQLException;
import java.util.List;

import static org.hamcrest.CoreMatchers.*;
import static org.junit.Assert.*;

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

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

    /**
     * MetadataField instance for the tests
     */
    private MetadataField mf;
    
    private MetadataSchema dcSchema;

    /**
     * Element of the metadata element
     */
    private String element = "contributor";

    /**
     * Qualifier of the metadata element
     */
    private String qualifier = "author";

    /**
     * Scope note of the metadata element
     */
    private String scopeNote = "scope note";

    protected MetadataSchemaService metadataSchemaService = ContentServiceFactory.getInstance().getMetadataSchemaService();
    protected MetadataFieldService metadataFieldService = ContentServiceFactory.getInstance().getMetadataFieldService();

    /**
     * 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
        {
            this.dcSchema = metadataSchemaService.find(context, MetadataSchema.DC_SCHEMA);
            this.mf = metadataFieldService.findByElement(context,
                    MetadataSchema.DC_SCHEMA, element, qualifier);
            if(mf == null)
            {
                context.turnOffAuthorisationSystem();
                this.mf = metadataFieldService.create(context, metadataSchemaService.find(context, MetadataSchema.DC_SCHEMA), element, qualifier, scopeNote);
                context.restoreAuthSystemState();
            }

            this.mf.setScopeNote(scopeNote);
        }
        catch (SQLException ex)
        {
            log.error("SQL Error in init", ex);
            fail("SQL Error in init: " + ex.getMessage());
        } catch (NonUniqueMetadataException ex) {
            log.error("NonUniqueMetadataException Error in init", ex);
            fail("NonUniqueMetadataException Error in init: " + ex.getMessage());
        } catch (AuthorizeException ex) {
            log.error("AuthorizeException Error in init", ex);
            fail("AuthorizeException 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()
    {
        mf = null;
        super.destroy();
    }

    /**
     * Test of getElement method, of class MetadataField.
     */
    @Test
    public void testGetElement() 
    {
        assertThat("testGetElement 0",mf.getElement(), equalTo(element));
    }

    /**
     * Test of setElement method, of class MetadataField.
     */
    @Test
    public void testSetElement()
    {
        String elem = "newelem";
        mf.setElement(elem);
        assertThat("testSetElement 0",mf.getElement(), equalTo(elem));
    }

    /**
     * Test of getFieldID method, of class MetadataField.
     */
    @Test
    public void testGetFieldID()
    {
        assertTrue("testGetFieldID 0",mf.getID() >= 0);
    }

    /**
     * Test of getQualifier method, of class MetadataField.
     */
    @Test
    public void testGetQualifier() 
    {
        assertThat("testGetQualifier 0",mf.getQualifier(), equalTo(qualifier));
    }

    /**
     * Test of setQualifier method, of class MetadataField.
     */
    @Test
    public void testSetQualifier()
    {
        String qual = "qualif";
        mf.setQualifier(qual);
        assertThat("testSetQualifier 0",mf.getQualifier(), equalTo(qual));
    }

    /**
     * Test of getSchemaID method, of class MetadataField.
     */
    @Test
    public void testGetSchema()
    {
        assertThat("testGetSchemaID 0",mf.getMetadataSchema().getName(), equalTo(MetadataSchema.DC_SCHEMA));
    }

    /**
     * Test of setSchemaID method, of class MetadataField.
     */
    @Test
    public void testSetSchema() throws NonUniqueMetadataException, SQLException, AuthorizeException
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow full admin permissions
            authorizeService.isAdmin(context); result = true;
        }};
        MetadataSchema newSchema = metadataSchemaService.create(context, "testSetSchema", "testSetSchemaNS");
        mf.setMetadataSchema(newSchema);
        assertThat("testSetSchemaID 0",mf.getMetadataSchema(), equalTo(newSchema));
    }

    /**
     * Test of getScopeNote method, of class MetadataField.
     */
    @Test
    public void testGetScopeNote()
    {
        assertThat("testGetScopeNote 0",mf.getScopeNote(), equalTo(scopeNote));
    }

    /**
     * Test of setScopeNote method, of class MetadataField.
     */
    @Test
    public void testSetScopeNote()
    {
        String scn = "new scope note";
        mf.setScopeNote(scn);
        assertThat("testSetScopeNote 0",mf.getScopeNote(), equalTo(scn));
    }

    /**
     * Test of create method, of class MetadataField.
     */
    @Test
    public void testCreateAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow full admin permissions
            authorizeService.isAdmin(context); result = true;
        }};

        String elem = "elem1";
        String qual = "qual1";
        MetadataField m = metadataFieldService.create(context, dcSchema, elem, qual, null);

        MetadataField found = metadataFieldService.findByElement(context, dcSchema, elem, qual);
        assertThat("testCreateAuth 0",found.getID(), equalTo(m.getID()));
    }

    /**
     * Test of create method, of class MetadataField.
     */
    @Test(expected=AuthorizeException.class)
    public void testCreateNoAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Disallow full admin permissions
            authorizeService.isAdmin(context); result = false;
        }};

        String elem = "elem1";
        String qual = "qual1";
        metadataFieldService.create(context, dcSchema, elem, qual, null);
        fail("Exception expected");
    }

    /**
     * Test of create method, of class MetadataField.
     */
    @Test(expected=NonUniqueMetadataException.class)
    public void testCreateRepeated() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow full admin permissions
            authorizeService.isAdmin(context); result = true;
        }};

        String elem = element;
        String qual = qualifier;
        metadataFieldService.create(context, dcSchema, elem, qual, null);
        fail("Exception expected");
    }

    /**
     * Test of findByElement method, of class MetadataField.
     */
    @Test
    public void testFindByElement() throws Exception
    {
        MetadataField found = metadataFieldService.findByElement(context, MetadataSchema.DC_SCHEMA, element, qualifier);
        assertThat("testFindByElement 0",found, notNullValue());
        assertThat("testFindByElement 1",found.getID(), equalTo(mf.getID()));
        assertThat("testFindByElement 2",found.getElement(), equalTo(mf.getElement()));
        assertThat("testFindByElement 3",found.getQualifier(), equalTo(mf.getQualifier()));        
    }

    /**
     * Test of findAll method, of class MetadataField.
     */
    @Test
    public void testFindAll() throws Exception
    {
        List<MetadataField> found = metadataFieldService.findAll(context);
        assertThat("testFindAll 0",found, notNullValue());
        assertTrue("testFindAll 1",found.size() >= 1);

        boolean added = false;
        for(MetadataField mdf: found)
        {
            if(mdf.equals(mf))
            {
                added = true;
            }
        }        
        assertTrue("testFindAll 2",added);
    }

    /**
     * Test of findAllInSchema method, of class MetadataField.
     */
    @Test
    public void testFindAllInSchema() throws Exception 
    {
        List<MetadataField> found = metadataFieldService.findAllInSchema(context, metadataSchemaService.find(context, MetadataSchema.DC_SCHEMA));
        assertThat("testFindAllInSchema 0",found, notNullValue());
        assertTrue("testFindAllInSchema 1",found.size() >= 1);
        assertTrue("testFindAllInSchema 2",found.size() <= metadataFieldService.findAll(context).size());

        boolean added = false;
        for(MetadataField mdf: found)
        {
            if(mdf.equals(mf))
            {
                added = true;
            }
        }        
        assertTrue("testFindAllInSchema 3",added);
    }

    /**
     * Test of update method, of class MetadataField.
     */
    @Test
    public void testUpdateAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow full admin permissions
            authorizeService.isAdmin(context); result = true;
        }};

        String elem = "elem2";
        String qual = "qual2";
        MetadataField m = metadataFieldService.create(context, dcSchema, elem, qual, null);
        metadataFieldService.update(context, m);

        MetadataField found = metadataFieldService.findByElement(context, MetadataSchema.DC_SCHEMA, elem, qual);
        assertThat("testUpdateAuth 0",found.getID(), equalTo(m.getID()));
    }

    /**
     * Test of update method, of class MetadataField.
     */
    @Test(expected=AuthorizeException.class)
    public void testUpdateNoAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Disallow full admin permissions
            authorizeService.isAdmin(context); result = false;
        }};

        String elem = "elem2";
        String qual = "qual2";
        MetadataField m = metadataFieldService.create(context, dcSchema, elem, qual, null);
        metadataFieldService.update(context, m);
        fail("Exception expected");
    }

    /**
     * Test of update method, of class MetadataField.
     */
    @Test(expected=NonUniqueMetadataException.class)
    public void testUpdateRepeated() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow full admin permissions
            authorizeService.isAdmin(context); result = true;
        }};

        String elem = element;
        String qual = qualifier;
        MetadataField m = metadataFieldService.create(context, dcSchema, elem, qual, null);

        m.setElement(elem);
        m.setQualifier(qual);
        metadataFieldService.update(context, m);
        fail("Exception expected");
    }

    /**
     * Test of delete method, of class MetadataField.
     */
    @Test
    public void testDeleteAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Allow full admin permissions
            authorizeService.isAdmin(context); result = true;
        }};

        String elem = "elem3";
        String qual = "qual3";
        MetadataField m = metadataFieldService.create(context, dcSchema, elem, qual, null);

        metadataFieldService.delete(context, m);

        MetadataField found = metadataFieldService.findByElement(context, MetadataSchema.DC_SCHEMA, elem, qual);
        assertThat("testDeleteAuth 0",found, nullValue());
    }

    /**
     * Test of delete method, of class MetadataField.
     */
    @Test(expected=AuthorizeException.class)
    public void testDeleteNoAuth() throws Exception
    {
        new NonStrictExpectations(authorizeService.getClass())
        {{
            // Disallow full admin permissions
            authorizeService.isAdmin(context); result = false;
        }};

        String elem = "elem3";
        String qual = "qual3";
        MetadataField m = metadataFieldService.create(context, dcSchema, elem, qual, null);

        metadataFieldService.delete(context, m);
        fail("Exception expected");
    }

    /**
     * Test of find method, of class MetadataField.
     */
    @Test
    public void testFind() throws Exception
    {
        int id = mf.getID();
        
        MetadataField found = metadataFieldService.find(context, id);
        assertThat("testFind 0",found, notNullValue());
        assertThat("testFind 1",found.getID(), equalTo(mf.getID()));
    }

}