package sheypme.com.sheypme.signUp.activity.presenter;

import android.accounts.Account;
import android.app.Activity;
import android.content.Context;
import android.support.v4.app.FragmentActivity;

import com.facebook.CallbackManager;
import com.facebook.login.LoginManager;
import com.google.android.gms.auth.UserRecoverableAuthException;

import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;

import java.util.Arrays;
import java.util.List;

import sheypme.com.sheypme.base.appPreferences.AppPreferences;
import sheypme.com.sheypme.base.interactor.listener.BaseInteractorListener;
import sheypme.com.sheypme.base.tokenPreferences.TokenPreferences;
import sheypme.com.sheypme.interactors.facebook.FacebookInteractor;
import sheypme.com.sheypme.interactors.facebook.listener.FacebookListener;
import sheypme.com.sheypme.interactors.google.GoogleInteractor;
import sheypme.com.sheypme.interactors.google.listener.GoogleListener;
import sheypme.com.sheypme.interactors.login.LoginInteractor;
import sheypme.com.sheypme.interactors.login.listener.LoginListener;
import sheypme.com.sheypme.interactors.register.RegisterInteractor;
import sheypme.com.sheypme.interactors.register.listener.RegisterListener;
import sheypme.com.sheypme.models.authData.AuthData;
import sheypme.com.sheypme.models.authData.UserData;
import sheypme.com.sheypme.models.authUser.AuthUser;
import sheypme.com.sheypme.signUp.activity.view.SignUpActivity;
import sheypme.com.sheypme.signUp.activity.view.SignUpActivityView;

import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static sheypme.com.sheypme.base.errorMessageHandler.ErrorMessageHandler.TAG_NETWORK_ERROR;
import static sheypme.com.sheypme.interactors.register.RegisterInteractor.TAG_REGISTER;

/**
 * Created on 14/03/17.
 */
public class SignUpActivityPresenterImplTest {

    @Mock
    TokenPreferences tokenPreferences;
    @Mock
    SignUpActivityView signUpActivityView;
    @Mock
    GoogleInteractor googleInteractor;
    @Mock
    FacebookInteractor facebookInteractor;
    @Mock
    LoginInteractor loginInteractor;
    @Mock
    RegisterInteractor registerInteractor;
    @Mock
    AppPreferences appPreferences;
    @Mock
    LoginManager loginManager;
    private SignUpActivityPresenterImpl signUpActivityPresenter;

    @Before
    public void setup() throws Exception {
        MockitoAnnotations.initMocks(this);
        //signUpActivityPresenter = new SignUpActivityPresenterImpl(signUpActivityView, googleInteractor, facebookInteractor, loginInteractor, registerInteractor, tokenPreferences, loginManager, appPreferences);
        signUpActivityPresenter.initialize(SignUpActivity.MODE_SIGN_IN);
    }

    @Test
    public void initializeSignIn() throws Exception {
        verify(signUpActivityView).setupSignInViews();
    }

    @Test
    public void initializeSignUp() throws Exception {
        signUpActivityPresenter.initialize(SignUpActivity.MODE_SIGN_UP);
        verify(signUpActivityView).setupSignUpViews();
    }

    /**
     * nothing to test except the call. We need to test interactor impl for more.
     *
     * @throws Exception if fails
     */

    @Test
    public void googleRegister() throws Exception {
        FragmentActivity fragmentActivity = Mockito.mock(FragmentActivity.class);
        ArgumentCaptor<BaseInteractorListener> baseInteractorListenerArgumentCaptor = ArgumentCaptor.forClass(BaseInteractorListener.class);
        signUpActivityPresenter.googleRegister(fragmentActivity);
        verify(googleInteractor).loginRegisterGoogle(eq(fragmentActivity), baseInteractorListenerArgumentCaptor.capture());
    }

    /**
     * nothing to test except the call. We need to test interactor impl for more.
     *
     * @throws Exception
     */
    @Test
    public void initFacebookRegister() throws Exception {
        ArgumentCaptor<CallbackManager> callbackManagerArgumentCaptor = ArgumentCaptor.forClass(CallbackManager.class);
        ArgumentCaptor<FacebookListener> facebookListenerArgumentCaptor = ArgumentCaptor.forClass(FacebookListener.class);
        signUpActivityPresenter.initFacebookRegister();
        verify(facebookInteractor).loginRegisterFacebook(callbackManagerArgumentCaptor.capture(), facebookListenerArgumentCaptor.capture());
    }

    @Test
    public void loginRegisterFacebook() throws Exception {
        Activity activity = Mockito.mock(Activity.class);
        List<String> permissionParams = Arrays.asList("email", "public_profile");

        signUpActivityPresenter.loginRegisterFacebook(activity);
        verify(loginManager).logInWithReadPermissions(activity, permissionParams);
    }

    @Test
    public void registerServiceFacebookValid() throws Exception {
        String service = LoginInteractor.SERVICE_FACEBOOK;
        String token = "valid_token";
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        Account account = Mockito.mock(Account.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        AuthData authData = Mockito.spy(new AuthData());
        UserData userMetaData = mock(UserData.class);
        ArgumentCaptor<RegisterListener> registerListenerArgumentCaptor = ArgumentCaptor.forClass(RegisterListener.class);

        Mockito.when(authData.getUserMetaData()).thenReturn(userMetaData);

        signUpActivityPresenter.registerByService(service, authUser, token);
        verify(registerInteractor).registerService(eq(service), eq(token), eq(email), eq(name), eq(lastName), registerListenerArgumentCaptor.capture());

        registerListenerArgumentCaptor.getValue().onSuccess(service, authData);
        verify(signUpActivityView).runCreatePlanActivity(authData);
    }

    @Test
    public void registerServiceFacebookInvalid() throws Exception {
        String service = LoginInteractor.SERVICE_FACEBOOK;
        String token = "valid_token";
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        String errorMessage = "error";
        Account account = Mockito.mock(Account.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        AuthData authData = Mockito.spy(new AuthData());
        UserData userMetaData = mock(UserData.class);
        ArgumentCaptor<RegisterListener> registerListenerArgumentCaptor = ArgumentCaptor.forClass(RegisterListener.class);

        Mockito.when(authData.getUserMetaData()).thenReturn(userMetaData);

        signUpActivityPresenter.registerByService(service, authUser, token);
        verify(registerInteractor).registerService(eq(service), eq(token), eq(email), eq(name), eq(lastName), registerListenerArgumentCaptor.capture());

        registerListenerArgumentCaptor.getValue().onRequestFailed(service, errorMessage);
        verify(signUpActivityView).makeErrorSnackBar(errorMessage);
    }

    /**
     * This test covers all data flow. Because of that, test is complex.
     *
     * @throws Exception
     */
    @Test
    public void getGoogleTokenValid() throws Exception {
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        String token = "jwtValidToken";
        String service = LoginInteractor.SERVICE_GOOGLE;
        Account account = Mockito.mock(Account.class);
        Context context = Mockito.mock(Context.class);
        UserData userMetaData = Mockito.mock(UserData.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        AuthData authData = Mockito.spy(new AuthData());

        ArgumentCaptor<GoogleListener> googleListenerArgumentCaptor = ArgumentCaptor.forClass(GoogleListener.class);
        ArgumentCaptor<LoginListener> loginListenerArgumentCaptor = ArgumentCaptor.forClass(LoginListener.class);
        Mockito.when(authData.getUserMetaData()).thenReturn(userMetaData);
        signUpActivityPresenter.getGoogleToken(context, authUser);

        verify(googleInteractor).getToken(eq(context), eq(authUser), googleListenerArgumentCaptor.capture());
        googleListenerArgumentCaptor.getValue().googleTokenSuccess(token, authUser);

        verify(loginInteractor).loginService(eq(service), eq(authUser), eq(token), loginListenerArgumentCaptor.capture());
        loginListenerArgumentCaptor.getValue().onSuccess(service, authData);
        verify(signUpActivityView).runCreatePlanActivity(authData);
    }

    @Test
    public void getGoogleTokenInvalid() throws Exception {
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        String token = "jwtValidToken";
        String errorMessage = "message";
        Account account = Mockito.mock(Account.class);
        Context context = Mockito.mock(Context.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        ArgumentCaptor<GoogleListener> googleListenerArgumentCaptor = ArgumentCaptor.forClass(GoogleListener.class);

        signUpActivityPresenter.getGoogleToken(context, authUser);

        verify(googleInteractor).getToken(eq(context), eq(authUser), googleListenerArgumentCaptor.capture());
        googleListenerArgumentCaptor.getValue().onRequestFailed(token, errorMessage);
        verify(signUpActivityView).makeErrorSnackBar(errorMessage);

    }

    /**
     * Validate case when there is user expection
     *
     * @throws Exception
     */
    @Test
    public void getGoogleExceptionInvalid() throws Exception {
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        Account account = Mockito.mock(Account.class);
        Context context = Mockito.mock(Context.class);
        UserRecoverableAuthException userRecoverableAuthException = Mockito.mock(UserRecoverableAuthException.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        ArgumentCaptor<GoogleListener> googleListenerArgumentCaptor = ArgumentCaptor.forClass(GoogleListener.class);

        signUpActivityPresenter.getGoogleToken(context, authUser);

        verify(googleInteractor).getToken(eq(context), eq(authUser), googleListenerArgumentCaptor.capture());
        googleListenerArgumentCaptor.getValue().authorisationException(userRecoverableAuthException);
        verify(signUpActivityView).requestGoogleAuthorisation(userRecoverableAuthException);
    }

    /**
     * Case when login fails
     *
     * @throws Exception
     */
    @Test
    public void getGoogleTokenLoginInvalid() throws Exception {
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        String token = "jwtValidToken";
        String errorMessage = "message";
        String service = LoginInteractor.SERVICE_GOOGLE;
        Account account = Mockito.mock(Account.class);
        Context context = Mockito.mock(Context.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        ArgumentCaptor<GoogleListener> googleListenerArgumentCaptor = ArgumentCaptor.forClass(GoogleListener.class);
        ArgumentCaptor<LoginListener> loginListenerArgumentCaptor = ArgumentCaptor.forClass(LoginListener.class);

        signUpActivityPresenter.getGoogleToken(context, authUser);

        verify(googleInteractor).getToken(eq(context), eq(authUser), googleListenerArgumentCaptor.capture());
        googleListenerArgumentCaptor.getValue().googleTokenSuccess(token, authUser);

        verify(loginInteractor).loginService(eq(service), eq(authUser), eq(token), loginListenerArgumentCaptor.capture());
        loginListenerArgumentCaptor.getValue().onRequestFailed(service, errorMessage);
        verify(signUpActivityView).makeErrorSnackBar(errorMessage);
    }

    @Test
    public void onNetworkError() throws Exception {
        String tag = TAG_NETWORK_ERROR;
        String errorMessage = "error";
        signUpActivityPresenter.onRequestFailed(tag, errorMessage);
        verify(signUpActivityView).makeNoInternetErrorSnackBar(errorMessage);
    }


    @Test
    public void requestRegistrationValid() throws Exception {

        String firstName = "first_name";
        String lastName = "last_name";
        String email = "valid_email@gmail.com";
        String token = "token";
        String service = LoginInteractor.SERVICE_FACEBOOK;//doesn't matter which service it is.
        AuthData authData = Mockito.spy(new AuthData()); //avoid using spy! http://softwareengineering.stackexchange.com/questions/212493/is-spying-on-tested-class-bad-practice
        UserData userMetaData = Mockito.mock(UserData.class);
        Account account = Mockito.mock(Account.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, firstName, lastName, account));
        Mockito.when(authData.getUserMetaData()).thenReturn(userMetaData);
        ArgumentCaptor<RegisterListener> registerListenerArgumentCaptor = ArgumentCaptor.forClass(RegisterListener.class);

        //signUpActivityPresenter.requestRegistration(service, authUser, token);

        verify(registerInteractor).registerService(eq(service), eq(token), eq(email), eq(firstName), eq(lastName), registerListenerArgumentCaptor.capture());
        //invoke success method on registration
        registerListenerArgumentCaptor.getValue().onSuccess(TAG_REGISTER, authData);
        //validate that on success block did his job
        verify(signUpActivityView).runCreatePlanActivity(authData);
    }

    @Test
    public void requestRegistrationInvalid() throws Exception {

        String firstName = "first_name";
        String lastName = "last_name";
        String email = "valid_email@gmail.com";
        String errorMessage = "errorMessage";
        String token = "token";
        String service = LoginInteractor.SERVICE_FACEBOOK;//doesn't matter which service it is.
        UserData userMetaData = Mockito.mock(UserData.class);
        Account account = Mockito.mock(Account.class);
        AuthData authData = Mockito.spy(new AuthData()); //avoid using spy! http://softwareengineering.stackexchange.com/questions/212493/is-spying-on-tested-class-bad-practice
        AuthUser authUser = Mockito.spy(new AuthUser(email, firstName, lastName, account));
        Mockito.when(authData.getUserMetaData()).thenReturn(userMetaData);
        ArgumentCaptor<RegisterListener> registerListenerArgumentCaptor = ArgumentCaptor.forClass(RegisterListener.class);

        //signUpActivityPresenter.requestRegistration(service, authUser, token);

        verify(registerInteractor).registerService(eq(service), eq(token), eq(email), eq(firstName), eq(lastName), registerListenerArgumentCaptor.capture());
        //invoke failed method on registration
        registerListenerArgumentCaptor.getValue().onRequestFailed(TAG_REGISTER, errorMessage);
        //validate that on error is called
        verify(signUpActivityView).makeErrorSnackBar(errorMessage);
    }

    /**
     * Because we can't test facebooks flow inside the {@link #loginRegisterFacebook()} we need to validate this callback!
     *
     * @throws Exception
     */
    @Test
    public void onSuccessFacebookNoMail() throws Exception {

        String service = LoginInteractor.SERVICE_FACEBOOK;
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        String token = "jwtValidToken";
        Account account = Mockito.mock(Account.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));

        Mockito.when(authUser.getMail()).thenReturn(null);

        signUpActivityPresenter.onSuccessFacebook(service, authUser, token);
        verify(signUpActivityView).showFacebookEmailDialog(service, authUser, token);
    }

    /**
     * Because we can't test facebooks flow inside the {@link #loginRegisterFacebook()} we need to validate this callback!
     *
     * @throws Exception
     */
    @Test
    public void onSuccessFacebookWithMailValid() throws Exception {

        String service = LoginInteractor.SERVICE_FACEBOOK;
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        String token = "jwtValidToken";
        Account account = Mockito.mock(Account.class);
        UserData userMetaData = Mockito.mock(UserData.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        AuthData authData = Mockito.spy(new AuthData()); //avoid using spy! http://softwareengineering.stackexchange.com/questions/212493/is-spying-on-tested-class-bad-practice
        ArgumentCaptor<LoginListener> loginListenerArgumentCaptor = ArgumentCaptor.forClass(LoginListener.class);
        Mockito.when(authData.getUserMetaData()).thenReturn(userMetaData);
        Mockito.when(authUser.getMail()).thenReturn(email);

        signUpActivityPresenter.onSuccessFacebook(service, authUser, token);
        verify(loginInteractor).loginService(eq(service), eq(authUser), eq(token), loginListenerArgumentCaptor.capture());

        loginListenerArgumentCaptor.getValue().onSuccess(service, authData);
        verify(signUpActivityView).runCreatePlanActivity(authData);
    }

    /**
     * Because we can't test facebooks flow inside the {@link #loginRegisterFacebook()} we need to validate this callback!
     *
     * @throws Exception
     */
    @Test
    public void onSuccessFacebookWithMailInvalid() throws Exception {

        String service = LoginInteractor.SERVICE_FACEBOOK;
        String email = "test@test.com";
        String name = "tester";
        String lastName = "lastName";
        String token = "jwtValidToken";
        String errorMessage = "message";
        Account account = Mockito.mock(Account.class);
        AuthUser authUser = Mockito.spy(new AuthUser(email, name, lastName, account));
        ArgumentCaptor<LoginListener> loginListenerArgumentCaptor = ArgumentCaptor.forClass(LoginListener.class);
        Mockito.when(authUser.getMail()).thenReturn(email);

        signUpActivityPresenter.onSuccessFacebook(service, authUser, token);
        verify(loginInteractor).loginService(eq(service), eq(authUser), eq(token), loginListenerArgumentCaptor.capture());

        loginListenerArgumentCaptor.getValue().onRequestFailed(service, errorMessage);
        verify(signUpActivityView).makeErrorSnackBar(errorMessage);
    }


}