guesstimate/client/src/hooks/use-project-reducer.ts

import { Project } from "../models/project";
import { Task, TaskID, EstimationConfidence, TaskCategoryID, TaskCategory } from "../models/task";
import { useReducer } from "react";
import { generate as diff } from "json-merge-patch";
import { applyPatch } from "../util/patch";


export interface Action {
  type: string
}

export type ProjectReducerActions =
AddTask |
RemoveTask |
UpdateTaskEstimation |
UpdateProjectLabel |
UpdateTaskLabel |
UpdateParam |
UpdateTaskCategoryLabel |
UpdateTaskCategoryCost |
AddTaskCategory |
RemoveTaskCategory |
PatchProject

export function useProjectReducer(project: Project) {
  return useReducer(projectReducer, project);
}

export function projectReducer(project: Project, action: ProjectReducerActions): Project {
  console.log(action);
  switch(action.type) {
    case ADD_TASK:
    return handleAddTask(project, action as AddTask);
    
    case REMOVE_TASK:
    return handleRemoveTask(project, action as RemoveTask);
    
    case UPDATE_TASK_ESTIMATION:
    return handleUpdateTaskEstimation(project, action as UpdateTaskEstimation);
    
    case UPDATE_PROJECT_LABEL:
    return handleUpdateProjectLabel(project, action as UpdateProjectLabel);
    
    case UPDATE_TASK_LABEL:
    return handleUpdateTaskLabel(project, action as UpdateTaskLabel);
    
    case UPDATE_PARAM:
    return handleUpdateParam(project, action as UpdateParam);
    
    case ADD_TASK_CATEGORY:
    return handleAddTaskCategory(project, action as AddTaskCategory);
    
    case REMOVE_TASK_CATEGORY:
    return handleRemoveTaskCategory(project, action as RemoveTaskCategory);
    
    case UPDATE_TASK_CATEGORY_LABEL:
    return handleUpdateTaskCategoryLabel(project, action as UpdateTaskCategoryLabel);
    
    case UPDATE_TASK_CATEGORY_COST:
    return handleUpdateTaskCategoryCost(project, action as UpdateTaskCategoryCost);
    
    case PATCH_PROJECT:
    return handlePatchProject(project, action as PatchProject);
  }
  
  return project;
}

export interface AddTask extends Action {
  task: Task
}

export const ADD_TASK = "ADD_TASK";

export function addTask(task: Task): AddTask {
  return { type: ADD_TASK, task };
}

export function handleAddTask(project: Project, action: AddTask): Project {
  const task = { ...action.task };
  return {
    ...project,
    tasks: {
      ...project.tasks,
      [task.id]: task,
    }
  };
}

export interface RemoveTask extends Action {
  id: TaskID
}

export const REMOVE_TASK = "REMOVE_TASK";

export function removeTask(id: TaskID): RemoveTask {
  return { type: REMOVE_TASK, id };
}

export function handleRemoveTask(project: Project, action: RemoveTask): Project {
  const tasks = { ...project.tasks };
  delete tasks[action.id];
  return {
    ...project,
    tasks
  };
}

export interface UpdateTaskEstimation extends Action {
  id: TaskID
  confidence: string
  value: number
}

export const UPDATE_TASK_ESTIMATION = "UPDATE_TASK_ESTIMATION";

export function updateTaskEstimation(id: TaskID, confidence: EstimationConfidence, value: number): UpdateTaskEstimation {
  return { type: UPDATE_TASK_ESTIMATION, id, confidence, value };
}

export function handleUpdateTaskEstimation(project: Project, action: UpdateTaskEstimation): Project {
  const estimations = {
    ...project.tasks[action.id].estimations,
    [action.confidence]: action.value
  };
  
  if (estimations.likely < estimations.optimistic) {
    estimations.likely = estimations.optimistic;
  }
  
  if (estimations.pessimistic < estimations.likely) {
    estimations.pessimistic = estimations.likely;
  }
  
  return {
    ...project,
    tasks: {
      ...project.tasks,
      [action.id]: {
        ...project.tasks[action.id],
        estimations: estimations,
      }
    }
  };
}


export interface UpdateProjectLabel extends Action {
  label: string
}

export const UPDATE_PROJECT_LABEL = "UPDATE_PROJECT_LABEL";

export function updateProjectLabel(label: string): UpdateProjectLabel {
  return { type: UPDATE_PROJECT_LABEL, label };
}

export function handleUpdateProjectLabel(project: Project, action: UpdateProjectLabel): Project {
  return {
    ...project,
    label: action.label
  };
}

export interface UpdateTaskLabel extends Action {
  id: TaskID
  label: string
}

export const UPDATE_TASK_LABEL = "UPDATE_TASK_LABEL";

export function updateTaskLabel(id: TaskID, label: string): UpdateTaskLabel {
  return { type: UPDATE_TASK_LABEL, id, label };
}

export function handleUpdateTaskLabel(project: Project, action: UpdateTaskLabel): Project {
  return {
    ...project,
    tasks: {
      ...project.tasks,
      [action.id]: {
        ...project.tasks[action.id],
        label: action.label,
      }
    }
  };
}

export interface UpdateParam extends Action {
  name: string
  value: any
}

export const UPDATE_PARAM = "UPDATE_PARAM";

export function updateParam(name: string, value: any): UpdateParam {
  return { type: UPDATE_PARAM, name, value };
}

export function handleUpdateParam(project: Project, action: UpdateParam): Project {
  return {
    ...project,
    params: {
      ...project.params,
      [action.name]: action.value,
    }
  };
}

export interface UpdateTaskCategoryLabel extends Action {
  categoryId: TaskCategoryID
  label: string
}

export const UPDATE_TASK_CATEGORY_LABEL = "UPDATE_TASK_CATEGORY_LABEL";

export function updateTaskCategoryLabel(categoryId: TaskCategoryID, label: string): UpdateTaskCategoryLabel {
  return { type: UPDATE_TASK_CATEGORY_LABEL, categoryId, label };
}

export function handleUpdateTaskCategoryLabel(project: Project, action: UpdateTaskCategoryLabel): Project {
  return {
    ...project,
    params: {
      ...project.params,
      taskCategories: {
        ...project.params.taskCategories,
        [action.categoryId]: {
          ...project.params.taskCategories[action.categoryId],
          label: action.label
        },
      }
    }
  };
}

export interface UpdateTaskCategoryCost extends Action {
  categoryId: TaskCategoryID
  costPerTimeUnit: number
}

export const UPDATE_TASK_CATEGORY_COST = "UPDATE_TASK_CATEGORY_COST";

export function updateTaskCategoryCost(categoryId: TaskCategoryID, costPerTimeUnit: number): UpdateTaskCategoryCost {
  return { type: UPDATE_TASK_CATEGORY_COST, categoryId, costPerTimeUnit };
}

export function handleUpdateTaskCategoryCost(project: Project, action: UpdateTaskCategoryCost): Project {
  return {
    ...project,
    params: {
      ...project.params,
      taskCategories: {
        ...project.params.taskCategories,
        [action.categoryId]: {
          ...project.params.taskCategories[action.categoryId],
          costPerTimeUnit: action.costPerTimeUnit
        },
      }
    }
  };
}

export const ADD_TASK_CATEGORY = "ADD_TASK_CATEGORY";

export interface AddTaskCategory extends Action {
  taskCategory: TaskCategory
}

export function addTaskCategory(taskCategory: TaskCategory): AddTaskCategory {
  return { type: ADD_TASK_CATEGORY, taskCategory };
}

export function handleAddTaskCategory(project: Project, action: AddTaskCategory): Project {
  const taskCategory = { ...action.taskCategory };
  return {
    ...project,
    params: {
      ...project.params,
      taskCategories: {
        ...project.params.taskCategories,
        [taskCategory.id]: taskCategory,
      }
    }
  };
}

export interface RemoveTaskCategory extends Action {
  taskCategoryId: TaskCategoryID
}

export const REMOVE_TASK_CATEGORY = "REMOVE_TASK_CATEGORY";

export function removeTaskCategory(taskCategoryId: TaskCategoryID): RemoveTaskCategory {
  return { type: REMOVE_TASK_CATEGORY, taskCategoryId };
}

export function handleRemoveTaskCategory(project: Project, action: RemoveTaskCategory): Project {
  const taskCategories = { ...project.params.taskCategories };
  delete taskCategories[action.taskCategoryId];
  return {
    ...project,
    params: {
      ...project.params,
      taskCategories
    }
  };
}

export interface PatchProject extends Action {
  from: Project
}

export const PATCH_PROJECT = "PATCH_PROJECT";

export function patchProject(from: Project): PatchProject {
  return { type: PATCH_PROJECT, from };
}

export function handlePatchProject(project: Project, action: PatchProject): Project {
  const p = diff(project, action.from);
  console.log('patch to apply', p);
  if (!p) return project;
  return applyPatch(project, p) as Project;
}