import { Project } from "../types/project";
import { Task, TaskID, EstimationConfidence, TaskCategoryID, TaskCategory } from "../types/task";
import { useReducerAndSaga } from "./useReducerAndSaga";
import { rootSaga } from "./useProjectReducer.sagas";
import { uuid } from "../util/uuid";
import { Params } from "../types/params";

export interface Action {
  type: string
}

export type ProjectReducerActions =
AddTask |
TaskSaved |
RemoveTask |
TaskRemoved |
UpdateTaskEstimation |
UpdateProjectTitle |
UpdateTaskLabel |
UpdateParam |
ParamsSaved |
UpdateTaskCategoryLabel |
UpdateTaskCategoryCost |
AddTaskCategory |
RemoveTaskCategory |
ResetProject

export function useProjectReducer(project: Project) {
  return useReducerAndSaga<Project>(projectReducer, project, rootSaga);
}

export function projectReducer(project: Project, action: ProjectReducerActions): Project {
  console.log(action.type, action);

  switch(action.type) {
    case TASK_SAVED:
    return handleTaskSaved(project, action as TaskSaved);
    
    case TASK_REMOVED:
    return handleTaskRemoved(project, action as RemoveTask);
    
    case UPDATE_TASK_ESTIMATION:
    return handleUpdateTaskEstimation(project, action as UpdateTaskEstimation);
    
    case UPDATE_PROJECT_TITLE:
    return handleUpdateProjectTitle(project, action as UpdateProjectTitle);
    
    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 RESET_PROJECT:
    return handleResetProject(project, action as ResetProject);
    
  }
  
  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 interface TaskAdded extends Action {
  task: Task
}

export const TASK_SAVED = "TASK_SAVED";

export interface TaskSaved extends Action {
  task: Task
}

export function taskSaved(task: Task): TaskSaved {
  return { type: TASK_SAVED, task };
}

export function handleTaskSaved(project: Project, action: TaskSaved): Project {
  const taskIndex = project.tasks.findIndex(t => t.id === action.task.id);
  const tasks = [ ...project.tasks ];
  if (taskIndex === -1) {
    tasks.push({ ...action.task });
  } else {
    tasks[taskIndex] = { ...tasks[taskIndex], ...action.task };
  }
  return {
    ...project,
    tasks
  };
}

export interface RemoveTask extends Action {
  id: number
}

export const REMOVE_TASK = "REMOVE_TASK";

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

export interface TaskRemoved extends Action {
  id: number
}

export const TASK_REMOVED = "TASK_REMOVED";

export function taskRemoved(id: number): TaskRemoved {
  return { type: TASK_REMOVED, id };
}


export function handleTaskRemoved(project: Project, action: TaskRemoved): Project {
  const tasks = [...project.tasks];
  const taskIndex = project.tasks.findIndex(t => t.id === action.id);
  if (taskIndex === -1) return project;
  tasks.splice(taskIndex, 1);
  return {
    ...project,
    tasks
  };
}

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

export const UPDATE_TASK_ESTIMATION = "UPDATE_TASK_ESTIMATION";

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

export function handleUpdateTaskEstimation(project: Project, action: UpdateTaskEstimation): Project {
  const tasks = [...project.tasks];
  const taskIndex = project.tasks.findIndex(t => t.id === action.id);
  if (taskIndex === -1) return project;
  
  const estimations = {
    ...project.tasks[taskIndex].estimations,
    [action.confidence]: action.value
  };

  project.tasks[taskIndex] = { ...project.tasks[taskIndex], estimations };
  
  return {
    ...project,
    tasks
  };
}


export interface UpdateProjectTitle extends Action {
  title: string
}

export const UPDATE_PROJECT_TITLE = "UPDATE_PROJECT_TITLE";

export function updateProjectTitle(title: string): UpdateProjectTitle {
  return { type: UPDATE_PROJECT_TITLE, title };
}

export function handleUpdateProjectTitle(project: Project, action: UpdateProjectTitle): Project {
  return {
    ...project,
    title: action.title
  };
}

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

export const UPDATE_TASK_LABEL = "UPDATE_TASK_LABEL";

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

export function handleUpdateTaskLabel(project: Project, action: UpdateTaskLabel): Project {
  const tasks = [...project.tasks];
  const taskIndex = project.tasks.findIndex(t => t.id === action.id);
  if (taskIndex === -1) return project;

  tasks[taskIndex] = { ...tasks[taskIndex], label: action.label };
  
  return {
    ...project,
    tasks
  };
}

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 ParamsSaved extends Action {
  params: Params
}

export const PARAMS_SAVED = "PARAMS_SAVED";

export function paramsSaved(params: Params): ParamsSaved {
  return { type: PARAMS_SAVED, params };
}

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,
    taskCategories: {
      ...project.taskCategories,
      [action.categoryId]: {
        ...project.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,
    taskCategories: {
      ...project.taskCategories,
      [action.categoryId]: {
        ...project.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,
    taskCategories: {
      ...project.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.taskCategories };
  delete taskCategories[action.taskCategoryId];
  return {
    ...project,
    taskCategories: {
      ...project.taskCategories,
      ...taskCategories
    }
  };
}

export interface ResetProject extends Action {
  project: Project
}

export const RESET_PROJECT = "RESET_PROJECT";

export function resetProject(project: Project): ResetProject {
  const newProject = JSON.parse(JSON.stringify(project));
  
  newProject.tasks.forEach(t => {
    if (!t.localId) t.localId = uuid();
  });

  newProject.taskCategories.forEach(tc => {
    if (!tc.localId) tc.localId = uuid();
  });

  return { type: RESET_PROJECT, project: newProject };
}

export function handleResetProject(project: Project, action: ResetProject): Project {
  return {
    ...project,
    ...action.project,
  };
}