import AsyncStorage from '@react-native-community/async-storage';
import {INTEGRATED_SOCIAL_LIST} from '../constants';
import {isUserBlocked, loadSocialPosts} from '../services';
import {
  loadAllSocials,
  loadBlockedList,
  loadFriendsData,
  loadRecentlySearched,
  loadUserData,
  loadUserMoments,
  loadUserNotifications,
  logout,
} from '../store/actions';
import {NO_SOCIAL_ACCOUNTS} from '../store/initialStates';
import {userLoggedIn} from '../store/reducers';
import {loadUserMomentCategories} from './../store/actions/momentCategories';
import {loadUserX} from './../store/actions/userX';
import {AppDispatch} from './../store/configureStore';
import {RootState} from './../store/rootReducer';
import {
  ProfilePreviewType,
  ProfileType,
  ScreenType,
  UserType,
} from './../types/types';

const loadData = async (dispatch: AppDispatch, user: UserType) => {
  await Promise.all([
    dispatch(loadUserData(user)),
    dispatch(loadFriendsData(user.userId)),
    dispatch(loadUserMomentCategories(user.userId)),
    dispatch(loadUserMoments(user.userId)),
    dispatch(loadUserNotifications()),
    dispatch(loadAllSocials(user.userId)),
    dispatch(loadBlockedList(user.userId)),
    dispatch(loadRecentlySearched()),
  ]);
};

/**
 * This tries to log the user in present with the AsyncStorage if user.userId is empty
 * Else it tries to login the user passed in
 * @param dispatch This is the dispatch object from the redux store
 * @param user The user if at all any
 */
export const userLogin = async (dispatch: AppDispatch, user: UserType) => {
  try {
    let localUser = {...user};
    if (!user.userId) {
      const [id, username, token] = await Promise.all([
        AsyncStorage.getItem('userId'),
        AsyncStorage.getItem('username'),
        AsyncStorage.getItem('token'),
      ]);
      if (id && username && token) {
        localUser = {...localUser, userId: id, username: username};
      } else {
        return;
      }
    } else {
      await Promise.all([
        AsyncStorage.setItem('userId', user.userId),
        AsyncStorage.setItem('username', user.username),
      ]);
    }
    await loadData(dispatch, localUser);
  } catch (error) {
    console.log(error);
  }
};

/**
 * This tries to load data userX passed in
 * @param dispatch This is the dispatch object from the redux store
 * @param user The user
 */
export const fetchUserX = async (
  dispatch: AppDispatch,
  user: UserType,
  screenType: ScreenType,
) => {
  try {
    await Promise.all([dispatch(loadUserX(user, screenType))]);
  } catch (error) {
    console.log(error);
  }
};

/**
 * This function checks if the userX slice of our store contains the given user for the provided Screen
 */
export const userXInStore = (
  state: RootState,
  screen: ScreenType,
  userId: string,
) => {
  const userX = state.userX[screen];
  return userId in userX && userX[userId].user.userId;
};

/**
 * Abstracted the code to laod all socials out.
 * @param userId userId for whom socials should be fetched
 */
export const loadAllSocialsForUser = async (userId: string) => {
  let socials = NO_SOCIAL_ACCOUNTS;
  try {
    let socialNeedsUpdate = INTEGRATED_SOCIAL_LIST;
    for (let socialType of socialNeedsUpdate) {
      const social = await loadSocialPosts(userId, socialType);
      socials = {...socials, [socialType]: social};
    }
    return socials;
  } catch (error) {
    console.log(error);
  }
};

/**
 * Push the user out of system if token is not present in async storage
 * @param dispatch
 */
export const getTokenOrLogout = async (dispatch: Function): Promise<string> => {
  const token = await AsyncStorage.getItem('token');
  if (!token) {
    dispatch({type: userLoggedIn.type, payload: {userId: '', username: ''}});
    return '';
  }
  return token;
};

/**
 * Creates ProfilePreviewType of a user using UserType && ProfileType
 * @param passedInUser This is the UserType of the user
 * @param passedInProfile This is the ProfileType of the user
 */
export const getUserAsProfilePreviewType = (
  passedInUser: UserType,
  passedInProfile: ProfileType,
): ProfilePreviewType => {
  const fullName = passedInProfile.name.split(' ');
  return {
    id: passedInUser.userId,
    username: passedInUser.username,
    first_name: fullName[0],
    last_name: fullName[1],
  };
};

export const checkIfUserIsBlocked = async (
  userId: string,
  dispatch: Function,
  loggedInUser: UserType,
) => {
  const token = await AsyncStorage.getItem('token');
  if (!token) {
    dispatch(logout());
    return false;
  }
  return await isUserBlocked(userId, loggedInUser.userId, token);
};