/* @flow */

import R from 'ramda';

// Utils
import * as crud from '../../utils/sequelize/crud';
import * as logic from '../../utils/logic/';
import facebook from '../../utils/facebook/';

// Models
import { Session, User } from '../models';

// Types
import type { SessionType } from '../Session/flow';
import type { UserType } from './flow';

type P<T> = Promise<T>;

type FacebookUserType = {
  email: string,
  first_name: string,
  last_name: string,
  birthday?: string,
  cover: string,
  gender?: string,
  link?: string,
};

type FormattedUserType = {
  email: string,
  password: boolean,
  firstname: string,
  lastname: string,
  username: string,
  userpic: string,
};

type ComposedUserDataType = {
  fbUser: FacebookUserType,
  user: UserType,
};

export const mutation: string = `
  authorization (
    token: String
  ): User
`;

export default {
  /**
   * Authorization via Facebook
   */
  authorization: async (
    root: any,
    { token }: { token: string },
  ): Promise<UserType> => {
    /**
     * Create new user session
     */
    const createSession = async (
      { id: userId }: UserType,
    ): P<SessionType> =>
      crud.create(
        'Session', {
          userId,
          token,
        },
      );

    /**
     * Register new user
     */
    const register = (
      { fbUser }: { fbUser: FacebookUserType },
    ): P<UserType> =>
      R.pipeP(
        () => facebook.user.format(fbUser, token),
        (formattedUser) => crud.create('User', formattedUser),
        (user) => R.pipe(
          () => {
            createSession(user);
            logic.createSelfBot(user.id);
          },
          R.always(user),
        )(user),
      )(fbUser);

    /**
     * Update user session
     */
    const update = (
      { user }: ComposedUserDataType,
    ): P<UserType> =>
      R.pipeP(
        (): P<SessionType> => Session.findOne({ where: { token } }),
        async (session): P<void> => R.isNil(session) && createSession(user),
        R.always(user),
      )(user);

    return R.pipeP(
      (): P<FacebookUserType> => facebook.user.get(token),
      async (fbUser) => ({
        fbUser,
        user: await User.findOne({ where: { email: fbUser.email } }),
      }),
      (args: ComposedUserDataType): P<UserType> => (
        R.isNil(R.prop('user', args))
          ? register(args)
          : update(args)
      ),
    )(token);
  },
};