export function todo(
  state = Record<TodoStateProp>({
    todoBoxId: null,
    todoIds: List(),
    todoEntities: Map(),
    todoBoxEntities: Map(),
    todoBoxIds: List()
  })(),
  action: any
) {
  switch (action.type) {
    case Actions.ADD_TODO.SUCCESS:
      const addedTodo = action.payload;
      return state
        .update('todoEntities', (todoEntities: any) =>
          todoEntities.set(String(addedTodo.id), fromJS(addedTodo))
        )
        .update('todoIds', (todoIds: any) => todoIds.push(String(addedTodo.id)));

    case Actions.GET_TODOLIST.REQUEST:
      return state.update('todoIds', () => List());

    case Actions.GET_TODOLIST.SUCCESS:
      const normalizedTodos = normalize(action.payload, TDS);
      return state
        .update('todoIds', () => List(normalizedTodos.result))
        .update('todoEntities', () => fromJS(normalizedTodos.entities.Todo || {}));

    case Actions.UPDATE_TODO.SUCCESS:
      return state.updateIn(['todoEntities', String(action.payload.id)], () =>
        fromJS(action.payload)
      );

    case Actions.DESTORY_TODO.SUCCESS:
      const toDeletedIndex = state.get('todoIds')!.indexOf(action.meta.id);
      return state.update('todoIds', (ids: any) => ids.delete(toDeletedIndex));

    case Actions.ADD_TODOBOX.SUCCESS:
      const normalizedAddedTodoBox = normalize(action.payload, TDBox);
      return state
        .update('todoBoxEntities', (todoBoxEntities: any) =>
          todoBoxEntities.merge(normalizedAddedTodoBox.entities.TodoBox)
        )
        .update('todoBoxIds', (todoBoxIds: any) => todoBoxIds.push(normalizedAddedTodoBox.result));

    case Actions.GET_TODOBOXS.SUCCESS:
      const normalizeTodoBox = normalize(action.payload, TDBoxs);
      return state
        .update('todoBoxIds', () => List(normalizeTodoBox.result))
        .update('todoBoxEntities', () => fromJS(normalizeTodoBox.entities.TodoBox || {}));

    default:
      return state;
  }
}

 return (dispatch, store) => {
   let normalized = normalize(data.entries, arrayOf(schema));
   // This is for testing only. If no results are returned, Normalizr will 
   // return result: [ undefined ] and entities[entity] = {undefined:{}}.
   if (normalized.result[0] === undefined) {
     normalized.result.length = 0;
     normalized.entities[toCamelCase(name)] = {};
   }
   // Dispatch event for the main data that was gathered on this request.
   // This includes metadata about the collection.
   dispatch(action(FIND, name.toUpperCase(), {
     result: normalized.result,
     items: normalized.entities[toCamelCase(name)],
     meta: {
       count: data.total_entries,
       page: data.page,
       links: data._links
     }
   }));
   
   // Iterate over other objects that were returned (normalized) and 
   // dispatch add actions for them to get them into the store.
   for (let x in normalized.entities) {
     // Exclude main entity
     if (toLoudSnakeCase(x) !== toLoudSnakeCase(name)) {
       // Iterate over each object passed back and dispatch ADD action
       for (let y in normalized.entities[x]) {
         dispatch(action(ADD, toLoudSnakeCase(x), normalized.entities[x][y]));
       }
     }
   }
 }

 let processJob = function (job: JobModel) {
   let uniqueName = getJobIndexName(job.unique_name);
   if (!_.includes(newState.uniqueNames, uniqueName)) {
     newState.uniqueNames.push(uniqueName);
   }
   let normalizedJobs = normalize(job, JobSchema).entities.jobs;
   newState.byUniqueNames[uniqueName] = {
     ...newState.byUniqueNames[uniqueName], ...normalizedJobs[job.unique_name]
   };
   return newState;
 };

  protected normalize(response, schema) {

    let camelizedJson = camelizeKeys(response);

    let normalizedResponse = normalize(camelizedJson, schema);

    return {
      result: fromJS(normalizedResponse.result),
      entities: fromJS(normalizedResponse.entities)
    };
  }

export const users: Reducer<any> = (state = initialState, action: Action) => {
  switch (action.type) {
    case LOADING_USERS:
    case LOADING_USER:
      return state.set('loading', true);
    case LOADED_USERS:
      const normalizedUsers: IUsers = normalize(action.payload, arrayOf(userSchema));

      return state.withMutations(map => {
        map.set('loading', false);
        map.set('result', List(normalizedUsers.result));
        normalizedUsers.result.forEach((userId: number) => {
          map.setIn(
            ['entities', 'users', userId],
            new UserRecord(normalizedUsers.entities.users[userId])
          );
        });
      });
    case LOADED_USER:
      return state.withMutations(map => {
        map.set('loading', false);
        if (map.get('result').indexOf(action.payload.id) === -1) {
          map.update('result', list => list.push(action.payload.id));
        }
        map.setIn(
          ['entities', 'users', action.payload.id],
          new UserRecord(action.payload)
        );
      });
    case DELETING_USER:
      return state.setIn(['entities', 'users', action.payload.id, 'deleting'], true);
    case DELETED_USER:
      return state.withMutations(map => map
        .deleteIn(['entities', 'users', action.payload])
        .deleteIn(['result', map.get('result').indexOf(action.payload)])
      );
    case ADDING_USER:
      return state.set('adding', true);
    case ADDED_USER:
      return state.withMutations(map => map
        .setIn(['entities', 'users', action.payload.id], new UserRecord(action.payload))
        .update('result', list => list.push(action.payload.id))
        .set('adding', false)
      );
    case PATCHED_USER:
      return state
        .setIn(['entities', 'users', action.payload.id], new UserRecord(action.payload));

    default:
      return state;
  }
};

export const posts: Reducer<any> = (state = initialState, action: Action) => {
  switch (action.type) {
    case LOADING_POSTS:
    case LOADING_POST:
      return state.set('loading', true)
    case LOADED_POSTS:
      const normalizedPosts: IPosts = normalize(action.payload, arrayOf(postSchema))
      return state.withMutations(map => {
        map.set('loading', false)
        map.set('result', List(normalizedPosts.result))
        normalizedPosts.result.forEach((postId: number) => {
          normalizedPosts.entities.posts[postId].user = normalizedPosts.entities.users[normalizedPosts.entities.posts[postId].user]
          map.setIn(
            ['entities', 'posts', postId],
            new PostRecord(normalizedPosts.entities.posts[postId])
          )
        })
      })
    case LOADED_POST:
      return state.withMutations(map => {
        map.set('loading', false)
        if (map.get('result').indexOf(action.payload.id) === -1) {
          map.update('result', list => list.push(action.payload.id))
        }
        map.setIn(
          ['entities', 'posts', action.payload.id],
          new PostRecord(action.payload)
        )
      })
    case DELETING_POST:
      return state.setIn(['entities', 'posts', action.payload.id, 'deleting'], true)
    case DELETED_POST:
      return state.withMutations(map => map
        .deleteIn(['entities', 'posts', action.payload])
        .deleteIn(['result', map.get('result').indexOf(action.payload)])
      )
    case ADDING_POST:
      return state.set('adding', true)
    case ADDED_POST:
      return state.withMutations(map => map
        .setIn(['entities', 'posts', action.payload.id], new PostRecord(action.payload))
        .update('result', list => list.push(action.payload.id))
        .set('adding', false)
      )
    case PATCHED_POST:
      return state
        .setIn(['entities', 'posts', action.payload.id], new PostRecord(action.payload))

    default:
      return state
  }
}

 let processUser = function (user: UserModel) {
   if (!_.includes(newState.userNames, user.username)) {
     newState.userNames.push(user.username);
   }
   let normalizedUsers = normalize(user, UserSchema).entities.users;
   newState.byUserNames[user.username] = {
     ...newState.byUserNames[user.username], ...normalizedUsers[user.username]
   };
   if (newState.byUserNames[user.username].projects == null) {
     newState.byUserNames[user.username].projects = [];
   }
   return newState;
 };

 let processExperiment = function (experiment: ExperimentModel) {
   let uniqueName = getExperimentIndexName(experiment.unique_name);
   if (!_.includes(newState.uniqueNames, uniqueName)) {
     newState.uniqueNames.push(uniqueName);
   }
   let normalizedExperiments = normalize(experiment, ExperimentSchema).entities.experiments;
   newState.byUniqueNames[uniqueName] = {
     ...newState.byUniqueNames[uniqueName], ...normalizedExperiments[experiment.unique_name]
   };
   if (newState.byUniqueNames[uniqueName].jobs == null) {
     newState.byUniqueNames[uniqueName].jobs = [];
   }
   return newState;
 };

 let processGroup = function(group: GroupModel) {
   let uniqueName = group.unique_name;
   if (!_.includes(newState.uniqueNames, uniqueName)) {
     newState.uniqueNames.push(uniqueName);
   }
   let normalizedGroups = normalize(group, GroupSchema).entities.groups;
   newState.byUniqueNames[uniqueName] = {
     ...newState.byUniqueNames[uniqueName], ...normalizedGroups[uniqueName]
   };
   if (newState.byUniqueNames[uniqueName].experiments == null) {
     newState.byUniqueNames[uniqueName].experiments = [];
   }
   return newState;
 };

 let processProject = function(project: ProjectModel) {
   let uniqueName = project.unique_name;
   if (!_.includes(newState.uniqueNames, uniqueName)) {
     newState.uniqueNames.push(uniqueName);
   }
   let normalizedProjects = normalize(project, ProjectSchema).entities.projects;
   newState.byUniqueNames[uniqueName] = {
     ...newState.byUniqueNames[uniqueName], ...normalizedProjects[uniqueName]
   };
   if (newState.byUniqueNames[uniqueName].experiments == null) {
     newState.byUniqueNames[uniqueName].experiments = [];
   }
   if (newState.byUniqueNames[uniqueName].groups == null) {
     newState.byUniqueNames[uniqueName].groups = [];
   }
   return newState;
 };