package com.atlassian.jira.rpc.soap.service;

import com.atlassian.crowd.embedded.api.CrowdService;
import com.atlassian.crowd.embedded.api.Group;
import com.atlassian.crowd.embedded.api.User;
import com.atlassian.crowd.embedded.impl.ImmutableGroup;
import com.atlassian.crowd.exception.OperationNotPermittedException;
import com.atlassian.crowd.exception.embedded.InvalidGroupException;
import com.atlassian.jira.bc.filter.SearchRequestService;
import com.atlassian.jira.bc.group.GroupService;
import com.atlassian.jira.bc.user.UserServiceResultHelper;
import com.atlassian.jira.component.ComponentAccessor;
import com.atlassian.jira.config.properties.APKeys;
import com.atlassian.jira.config.properties.ApplicationProperties;
import com.atlassian.jira.exception.CreateException;
import com.atlassian.jira.exception.PermissionException;
import com.atlassian.jira.mock.component.MockComponentWorker;
import com.atlassian.jira.rpc.exception.RemoteException;
import com.atlassian.jira.rpc.mock.MockUser;
import com.atlassian.jira.rpc.soap.util.MockRemoteEntityFactory;
import com.atlassian.jira.rpc.soap.util.RemoteEntityFactory;
import com.atlassian.jira.security.GlobalPermissionManager;
import com.atlassian.jira.security.PermissionManager;
import com.atlassian.jira.security.Permissions;
import com.atlassian.jira.security.groups.GroupManager;
import com.atlassian.jira.user.util.UserUtil;
import com.atlassian.jira.util.ErrorCollection;
import com.atlassian.jira.util.SimpleErrorCollection;
import org.junit.Before;
import org.junit.Test;

import java.util.Collections;

import static org.junit.Assert.fail;
import static org.mockito.Mockito.*;

public class TestUserServiceImplWithExternalManagement
{
    private GroupManager mockGroupManager;
    private PermissionManager mockPermissionManager;
    private ApplicationProperties mockApplicationProperties;
    private com.atlassian.jira.bc.user.UserService mockUserService;
    private MockComponentWorker mockComponentWorker;

    private UserService userService;
    private User user;
    private User user2;
    private User user3;

    @Before
    public void setUp() throws Exception
    {
        mockComponentWorker = new MockComponentWorker();
        ComponentAccessor.initialiseWorker(mockComponentWorker);
        mockPermissionManager = mock(PermissionManager.class);
        mockApplicationProperties = mock(ApplicationProperties.class);
        mockGroupManager = mock(GroupManager.class);
        mockUserService = mock(com.atlassian.jira.bc.user.UserService.class);

        final RemoteEntityFactory mockRemoteEntityFactory = new MockRemoteEntityFactory();

        user = new MockUser("driver", "Test User", "test@test.com");
        user2 = new MockUser("driver2", "Test User", "test@test.com");
        user3 = new MockUser("driver3", "Test User", "test@test.com");

        userService = new UserServiceImpl
                (
                        mock(SearchRequestService.class), null, mockGroupManager, mockPermissionManager,
                        mockApplicationProperties, mockUserService, mock(GroupService.class), mockRemoteEntityFactory,
                        mock(CrowdService.class), mock(GlobalPermissionManager.class), mock(UserUtil.class)
                );
    }

    @Test
    public void testCreateUserWithExternalUserManagement() throws CreateException, PermissionException
    {
        com.atlassian.jira.bc.user.UserService.CreateUserValidationResult result =
                UserServiceResultHelper.getCreateUserValidationResult
                        (
                                "testuser",
                                "testpassword",
                                "user@email.com",
                                "first last"
                        );

        when(mockUserService.
                validateCreateUserForAdminPasswordRequired
                        (
                                user,
                                "testuser",
                                "testpassword",
                                "testpassword",
                                "user@email.com",
                                "first last"
                        )
        ).thenReturn(result);

        when(mockUserService.createUserWithNotification(result)).thenReturn(user);

        try
        {
            userService.createUser(user, "testuser", "testpassword", "first last", "user@email.com");
        }
        catch (RemoteException e)
        {
            fail("failed creating user without ext mgmt turned on");
        }

        ErrorCollection errors = new SimpleErrorCollection();
        errors.addErrorMessage("content");
        com.atlassian.jira.bc.user.UserService.CreateUserValidationResult errorResult =
                UserServiceResultHelper.getCreateUserValidationResult(errors);
        when(mockUserService.
                validateCreateUserForAdminPasswordRequired
                        (
                                user,
                                "testuser1",
                                "testpassword",
                                "testpassword",
                                "user@email.com",
                                "first last"
                        )).
                thenReturn(errorResult);

        try
        {
            userService.createUser(user, "testuser1", "testpassword", "first last", "user@email.com");
            fail("ext mgmt is turned on. Creation of user should have failed.");
        }
        catch (RemoteException e){}
    }

    @Test
    public void testDeleteUserWithExternalUserManagement()
    {
        com.atlassian.jira.bc.user.UserService.DeleteUserValidationResult result =
                UserServiceResultHelper.getDeleteUserValidationResult(user2);
        when(mockUserService.validateDeleteUser(user, user2.getName())).thenReturn(result);

        try
        {
            userService.deleteUser(user, user2.getName());
        }
        catch (RemoteException e)
        {
            fail("failed deleting user with ext mgmt turned off");
        }
        verify(mockUserService).removeUser(user, result);

        // just checking error - real external management is tested in UserUtil
        ErrorCollection errors = new SimpleErrorCollection();
        errors.addErrorMessage("error message");
        result = UserServiceResultHelper.getDeleteUserValidationResult(errors);
        when(mockUserService.validateDeleteUser(user, user3.getName())).thenReturn(result);

        try
        {
            userService.deleteUser(user, user3.getName());
            fail("ext mgmt is turned on. Deletion of user should have failed.");
        }
        catch (RemoteException e){}
    }

    @Test
    public void testCreateGroupWithExternalUserManagement() throws OperationNotPermittedException, InvalidGroupException
    {
        when(mockGroupManager.createGroup(("test-group"))).thenReturn(new ImmutableGroup("test-group"));
        when(mockPermissionManager.hasPermission(Permissions.ADMINISTER, user)).thenReturn(true);
        when(mockApplicationProperties.getOption(APKeys.JIRA_OPTION_USER_EXTERNALMGT)).thenReturn(false);


        final GlobalPermissionManager mockGlobalPermissionManager = mock(GlobalPermissionManager.class);
        when(mockGlobalPermissionManager.getGroupsWithPermission(Permissions.USE)).thenReturn(Collections.<Group>emptyList());

        try
        {
            userService.createGroup(user, "test-group", null);
        }
        catch (RemoteException e)
        {
            fail("failed creating group without ext mgmt turned on: " + e.getMessage());
        }
        when(mockApplicationProperties.getOption(APKeys.JIRA_OPTION_USER_EXTERNALMGT)).thenReturn(true);

        try
        {
            userService.createGroup(user, "testgroup2", null);
            fail("ext mgmt is turned on. Creation of group should have failed.");
        }
        catch (RemoteException e){}
    }
}