import { userReducer } from './user.reducer';
import {
  userAuthReturnRouteReset,
  userAuthReturnRouteSet,
  userCurrentSet,
  userDataSet,
  userDataUpdate,
  userDataUpdateSuccess,
  userLoggedOut,
  userPermissionsSet,
  userRoleSet,
} from './user.actions';
import { USER_DATA_UPDATE_ERROR } from 'app/modules/user/store/user.constants';
import { johnDoe } from 'app/testUtils/mocks/user.mock';
import { CurrentUser, UserState } from './user.types';

describe('User reducer tests', () => {
  const userData = {
    accessToken: 'accessToken',
  } as CurrentUser;

  const initialState = {
    current: null,
    data: {
      pools: [],
    },
    updating: false,
    permissions: [],
    welcomeInfo: {
      opened: false,
      showingAtStart: true,
      content: '',
    },
  };

  const authReturnRoute = '/test';

  it('returns the initial state', () => {
    expect(userReducer(undefined)).toEqual(initialState);
  });

  it('returns logged user for userSetCurrent action', () => {
    const loggedState = {
      current: userData,
    };

    const unloggedState = {
      current: null,
    } as UserState;

    const action = userCurrentSet(userData);

    expect(userReducer(unloggedState, action)).toEqual(loggedState);
  });

  it('returns logged out state for userLoggedOut action', () => {
    const loggedState = {
      current: userData,
    } as UserState;

    const unloggedState = initialState;

    const action = userLoggedOut();

    expect(userReducer(loggedState, action)).toEqual(unloggedState);
  });

  it('changes user data for userUpdateDataSuccess action', () => {
    const defaultState = {
      ...initialState,
      current: userData,
    };

    const userDataDetails = {
      country: 'Poland',
      name: 'Test name',
      phone: '605439640',
      pools: [],
    };

    const expectedState = {
      ...defaultState,
      current: userData, data: userDataDetails,
    };

    const action = userDataUpdateSuccess(userDataDetails);

    expect(userReducer(defaultState, action)).toEqual(expectedState);
  });

  it('doesnt change user data for userUpdateDataError action', () => {
    const defaultState = {
      current: userData,
      updating: false,
    } as UserState;

    const action = { type: USER_DATA_UPDATE_ERROR, payload: { errors: true } };

    expect(userReducer(defaultState, action)).toEqual(defaultState);
  });

  it('update start only changes updating flag', () => {
    const defaultState = {
      current: userData,
      updating: false,
    } as UserState;

    const userDataDetails = {
      country: 'Poland',
      name: 'Test name',
      phone: '605439640',
    };

    const expectedState = {
      current: userData,
      updating: true,
    };

    const action = userDataUpdate({ userDataDetails });

    expect(userReducer(defaultState, action)).toEqual(expectedState);
  });

  it('updates role when userRoleSet action is fired', () => {
    const expectedState = {
      ...initialState,
      role: 'user',
    };
    const action = userRoleSet('user');
    expect(userReducer(initialState, action)).toEqual(expectedState);
  });

  it('updates permissions list when userPermissionSet action is fired', () => {
    const permissions = [ 'allowToSeePage', 'allowedToEditDetails' ];
    const expectedState = {
      ...initialState,
      permissions: [ 'allowToSeePage', 'allowedToEditDetails' ],
    };
    const action = userPermissionsSet(permissions);
    expect(userReducer(initialState, action)).toEqual(expectedState);
  });

  it('changes user data when userDataSet action is fired', () => {
    const defaultState = {
      data: {},
    } as UserState;

    const userData = {
      ...johnDoe,
    };

    const expectedState = {
      data: userData,
    };

    const action = userDataSet(userData);

    expect(userReducer(defaultState, action)).toEqual(expectedState);
  });

  it('changes user auth return url when userAuthReturnRouteSet action is fired', () => {
    const defaultState = {} as UserState;
    const expectedState = {
      authReturnRoute: authReturnRoute,
    };

    const action = userAuthReturnRouteSet(authReturnRoute);

    expect(userReducer(defaultState, action)).toEqual(expectedState);
  });

  it('resets user auth return url when userAuthReturnRouteSet action is fired', () => {
    const currentState = {
      authReturnRoute: authReturnRoute,
    } as UserState;
    const expectedState = {
      authReturnRoute: null,
    };

    const action = userAuthReturnRouteReset();

    expect(userReducer(currentState, action)).toEqual(expectedState);
  });
});