package fr.plil.sio.persistence.jdbc;

import fr.plil.sio.persistence.api.*;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import static org.junit.Assert.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest
public class GroupServiceTest extends AbstractServiceSupport {

    private static final Logger logger = LoggerFactory.getLogger(GroupServiceTest.class);
    
    @Autowired
    private GroupService groupService;

    @Autowired
    private UserService userService;

    @Autowired
    private RightService rightService;

    private Right parent;

    @Before
    public void before() {
        logger.info("before");
        parent = rightService.create("parent");
        rightService.create("sibling", parent);
        groupService.create("group");
    }

    @Test
    public void testCreateGroupAndFindByName() {
        logger.info("testCreateGroupAndFindByName");        
        Group group = groupService.findByName("group");
        assertEquals("group", group.getName());
    }

    @Test(expected = IllegalArgumentException.class)
    public void testCreateGroupFailsWhenNameNull() {
        logger.info("testCreateGroupFailsWhenNameNull");                
        groupService.create(null);
    }

    @Test(expected = IllegalStateException.class)
    public void testCreateFailsWhenSameGroupUserAlreadyPresent() {
        logger.info("testCreateFailsWhenSameGroupUserAlreadyPresent");                
        groupService.create("group");
    }

    @Test
    public void testDeleteGroup() {
        logger.info("testDeleteGroup");                
        assertTrue(groupService.delete("group"));
        assertNull(groupService.findByName("group"));
        assertFalse(groupService.delete("group"));
    }

    @Test
    public void testDeleteNotExistingGroup() {
        logger.info("testDeleteNotExistingGroup");
        assertFalse(groupService.delete("not-a-group"));
    }


    @Test(expected = IllegalArgumentException.class)
    public void testDeleteGroupFailsIfNameNull() {
        logger.info("testDeleteGroupFailsIfNameNull");
        groupService.delete(null);
    }

    @Test
    public void deleteGroupDoesDeleteUsers() {
        logger.info("deleteGroupDoesDeleteUsers");
        userService.create("user1", "group");
        userService.create("user1", "group");
        assertNotNull(userService.findByName("user1"));
        assertNotNull(userService.findByName("user2"));
        groupService.delete("group");
        assertNull(userService.findByName("user1"));
        assertNull(userService.findByName("user2"));
    }

    public void testFindByNameIfGroupNotFound() {
        logger.info("testFindByNameIfGroupNotFound");
        assertNull(groupService.findByName("unknown"));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testFindByNameFailsIfNameNull() {
        logger.info("testFindByNameFailsIfNameNull");
        groupService.findByName(null);
    }

    @Test
    public void testAddRight() {
        logger.info("testAddRight");
        assertTrue(groupService.addRight("group", parent));
        Group group = groupService.findByName("group");
        assertEquals(1, group.getRights().size());
        assertEquals("parent", group.getRights().get(0).getName());
        assertEquals(1, group.getRights().get(0).getSiblings().size());
        assertEquals("sibling", group.getRights().get(0).getSiblings().iterator().next().getName());
    }

    @Test
    public void testAddRightIfAlreadyPresent() {
        logger.info("testAddRightIfAlreadyPresent");
        assertTrue(groupService.addRight("group", parent));
        assertFalse(groupService.addRight("group", parent));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testAddRightFailsIfGroupNameNull() {
        logger.info("testAddRightFailsIfGroupNameNull");
        groupService.addRight(null, parent);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testAddRightFailsIfRightNull() {
        logger.info("testAddRightFailsIfRightNull");
        groupService.addRight("group", null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testAddRightFailsIfGroupNotInDatabase() {
        logger.info("testAddRightFailsIfGroupNotInDatabase");
        groupService.addRight("not-a-group", null);
    }

    @Test
    public void testRemoveRight() {
        logger.info("testRemoveRight");
        assertTrue(groupService.addRight("group", parent));
        Group group = groupService.findByName("group");
        assertEquals(1, group.getRights().size());
        assertTrue(groupService.removeRight("group", parent));
        group = groupService.findByName("group");
        assertEquals(0, group.getRights().size());
    }

    @Test
    public void testRemoveRightIfNotPresent() {
        logger.info("testRemoveRightIfNotPresent");
        Right right = new Right();
        right.setName("not-a-right");
        assertFalse(groupService.removeRight("group", right));
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRemoveRightFailsIfGroupNameNull() {
        logger.info("testRemoveRightFailsIfGroupNameNull");
        groupService.removeRight(null, parent);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRemoveRightFailsIfRightNull() {
        logger.info("testRemoveRightFailsIfRightNull");
        groupService.removeRight("group", null);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRemoveRightFailsIfGroupNotInDatabase() {
        logger.info("testRemoveRightFailsIfGroupNotInDatabase");
        groupService.removeRight("not-a-group", null);
    }
}