import { Schema, arrayOf } from 'normalizr'

// Main Schema
const relationshipSchema = new Schema('relationships')

const website  = new Schema('websites')
const book     = new Schema('books')
const interest = new Schema('interests')
const virtue   = new Schema('virtues')
const feature  = new Schema('features')
const strength = new Schema('strengths')
const teacher  = new Schema('teachers')

relationshipSchema.define({
  websites: arrayOf(website),
  books: arrayOf(book),
  interests: arrayOf(interest),
  virtues: arrayOf(virtue),
  features: arrayOf(feature),
  strengths: arrayOf(strength),
  teacher: arrayOf(teacher),
})

export { relationshipSchema }

export const LOGIN_USER_INIT = 'LOGIN_USER_INIT'
export const LOGIN_USER_ERROR = 'LOGIN_USER_FAILURE'
export const LOGIN_USER_SUCCESS = 'LOGIN_USER_SUCCESS'

export const AUTH_USER = 'AUTH_USER'
export const UNAUTH_USER = 'UNAUTH_USER'

export const PASSWORD_RESET_INIT = 'PASSWORD_RESET_INIT'
export const PASSWORD_RESET_ERROR = 'PASSWORD_RESET_ERROR'
export const PASSWORD_RESET_SUCCESS = 'PASSWORD_RESET_SUCCESS'

// Packages
import { normalize } from 'normalizr'

// Schemas
import * as schema from './userSchema'

// Action Constants
import * as actions from './userActionTypes'

// Utils
import { startSession, resetPassword } from 'utils/users'

function authUser (authToken) {
  return {
    type: actions.AUTH_USER,
    authToken,
  }
}

function loginUserInit () {
  return {
    type: actions.LOGIN_USER_INIT,
  }
}

function loginUserSuccess (userId, user, timestamp) {
  return {
    type: actions.LOGIN_USER_SUCCESS,
    userId,
    user,
    timestamp,
  }
}

export function loginUserError (error) {
  console.warn(error)
  return {
    type: actions.LOGIN_USER_ERROR,
    error: 'Sorry! Your username and password didn\'t match. Please try again.',
  }
}

export function loginAndAuthUser (username, password) {
  return function (dispatch) {
    dispatch(loginUserInit())

    return startSession(username, password)
      .then((response) => {
        console.log('RESPONSE', response.data.data)

        const normalizedResponse = normalize(response.data.data.relationships, schema.relationshipSchema)
        console.log('Normalized Response', normalizedResponse)

        const userId    = response.data.data.id
        const userAttrs = response.data.data.attributes
        const userAuthToken = userAttrs['auth-token']
        dispatch(loginUserSuccess(userId, userAttrs, Date.now()))
        dispatch(authUser(userAuthToken))
      })
  }
}

export function passwordResetInit () {
  return {
    type: actions.PASSWORD_RESET_INIT,
  }
}

export function passwordResetSuccess () {
  return {
    type: actions.PASSWORD_RESET_SUCCESS,
  }
}

export function passwordResetError () {
  return {
    type: actions.PASSWORD_RESET_ERROR,
  }
}

export function sendPasswordReset (email) {
  return function (dispatch) {
    dispatch(passwordResetInit())
    return resetPassword(email)
      .then(() => dispatch(passwordResetSuccess()))
  }
}

import * as actions from './userActionTypes'

import { fromJS, Map } from 'immutable'

// Reducers
const initialUserState = fromJS({
  lastUpdated: 0,
  userId: '',
  info: {},
  relationships: {
    websites: [],
    books: [],
    movies: [],
    interests: [],
    virtues: [],
    features: [],
    strengths: [],
    teachers: [],
  },
})

function user (state = initialUserState, action) {
  switch (action.type) {
    case actions.LOGIN_USER_SUCCESS :
      return state.merge({
        userId: action.userId,
        info: action.user,
        lastUpdated: action.timestamp,
      })

    default:
      return state
  }
}

const initialState = Map({
  authToken: '',
  isAuthed: false,
  isFetching: false,
  isSubmitting: false,
  error: '',
  currentUser: {},
})

export default function users (state = initialState, action) {
  switch (action.type) {

    case actions.LOGIN_USER_INIT :
    case actions.PASSWORD_RESET_INIT :
    return state.merge({
      isSubmitting: true,
    })

    case actions.LOGIN_USER_ERROR :
    return state.merge({
      isSubmitting: false,
      error: action.error,
    })

    case actions.LOGIN_USER_SUCCESS :
    return state.merge({
      isSubmitting: false,
      error: '',
      currentUser: user(state[action.userId], action),
    })

    case actions.AUTH_USER :
      return state.merge({
        isAuthed: true,
        authToken: action.authToken,
      })

    case actions.UNAUTH_USER :
      return state.merge({
        isAuthed: false,
        authToken: '',
      })

    case actions.PASSWORD_RESET_SUCCESS :
    case actions.PASSWORD_RESET_ERROR :
      return state.merge({
        isSubmitting: false,
      })

    default :
      return state
  }
}