#include "process.h"

#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int klist_app_user_get(klist *ctx) {
  klist_user *user = klist_user_get_by_local(ctx, getuid());

  if (user) {
    printf("User: %p\nID: %lu\n", user->name, user->id);
    size_t lists_len = 0;
    klist_list **lists = klist_list_get_all_by_user(ctx, user->id, &lists_len);
    printf("Lists: %lu\n", lists_len);
    int i = 0;
    for (; i < lists_len; i++)
      klist_list_deinit(lists[i]);
  } else
    klist_print(ctx, KLIST_LOG_ERROR, "No user for '%s' found.\n", getlogin());
  return 0;
}

int klist_app_user_create(klist *ctx) {
  klist_print(ctx, KLIST_LOG_INFO,
              (klist_assure_user(ctx, getuid(), getlogin()))
                  ? "User created.\n"
                  : "User already exists.\n");
  return 0;
}

int klist_app_user_delete(klist *ctx) {
  klist_user *user = klist_user_get_by_local(ctx, getuid());
  if (user) {
    klist_user_delete(ctx, user);
    printf("User deleted.\n");
  } else
    klist_print(ctx, KLIST_LOG_ERROR, "User not found, no changes done.\n");
  return 0;
}

int klist_app_list_add(klist *ctx) {
  klist_list_context *list_ctx = ctx->cmd_ctx;
  if (!list_ctx->stages_len) {
    klist_print(ctx, KLIST_LOG_ERROR, "Missing stages.\n");
    return 1;
  }
  klist_assure_user(ctx, getuid(), getlogin());
  klist_user *user = klist_user_get_by_local(ctx, getuid());
  klist_list *list =
      klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);
  if (!list)
    list = klist_list_init();
  list->name = (unsigned char *)strdup(list_ctx->name);
  if (list->desc)
    list->desc = (unsigned char *)strdup(list_ctx->desc);
  list->is_preset = false;
  klist_list_save(ctx, list, user);
  int i = 0;
  for (; i < list_ctx->stages_len; i++) {
    klist_stage *stage = klist_stage_init();
    stage->name = (unsigned char *)strdup(list_ctx->stages[i]);
    stage->list_id = list->id;
    klist_stage_save(ctx, stage);
    klist_stage_deinit(stage);
  }
  return 0;
}

int klist_app_list_edit(klist *ctx) {
  klist_print(ctx, KLIST_LOG_ERROR, "Not implemented\n");
  return 0;
}

int klist_app_list_get(klist *ctx) {
  klist_list_context *list_ctx = ctx->cmd_ctx;
  klist_user *user = klist_user_get_by_local(ctx, getuid());

  size_t lists_len = 0;
  klist_list **lists = NULL;
  if (list_ctx->name) {
    klist_list *list =
        klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);
    if (list) {
      lists_len = 1;
      lists = malloc(lists_len * sizeof(klist_list));
      memcpy(lists[0], list, sizeof(klist_list));
      klist_list_deinit(list);
    };
  } else
    lists = klist_list_get_all_by_user(ctx, user->id, &lists_len);

  if (lists_len) {
    int i = 0;
    for (; i < lists_len; i++) {
      klist_list *list = lists[i];
      size_t tasks_len = 0;
      klist_task **tasks = klist_task_get_for_list(ctx, list->id, &tasks_len);
      printf("Name: %s\n", (char *)list->name);
      printf("Description: %s\n", list->desc ? (char *)list->desc : "N/A");
      printf("Tasks: %ld\n", tasks_len);
      i = 0;
      for (; i < tasks_len; i++)
        klist_task_deinit(tasks[i]);
      free(tasks);
      klist_list_deinit(list);
    }
    free(lists);
  } else if (list_ctx->name)
    klist_print(ctx, KLIST_LOG_ERROR, "List '%s' not found.\n", list_ctx->name);
  else
    klist_print(ctx, KLIST_LOG_WARNING, "No lists found.\n");
  return 0;
}

int klist_app_list_delete(klist *ctx) {
  klist_list_context *list_ctx = ctx->cmd_ctx;
  klist_assure_user(ctx, getuid(), getlogin());
  klist_user *user = klist_user_get_by_local(ctx, getuid());
  if (!user) {
    klist_print(ctx, KLIST_LOG_ERROR, "User doesn't exist.\n");
    return 1;
  }

  klist_list *list =
      klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);

  list = klist_list_get_by_user_and_name(ctx, user->id, list_ctx->name);
  if (list) {
    size_t tasks_len = 0;
    klist_task **tasks = klist_task_get_for_list(ctx, list->id, &tasks_len);
    int i = 0;
    for (; i < tasks_len; i++) {
      klist_task_delete(ctx, tasks[i]);
      klist_task_deinit(tasks[i]);
    }
    free(tasks);
  }
  return 0;
}

int klist_app_task_add(klist *ctx) { return klist_app_task_edit(ctx); }

int klist_app_task_edit(klist *ctx) {
  klist_task_context *task_ctx = ctx->cmd_ctx;
  klist_assure_user(ctx, getuid(), getlogin());
  klist_user *user = klist_user_get_by_local(ctx, getuid());
  klist_list *list = NULL;

  if (!user) {
    klist_print(ctx, KLIST_LOG_ERROR, "User doesn't exist.\n");
    return 1;
  }

  list = klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
  if (list) {
    size_t stages_len = 0;
    klist_stage **stages =
        klist_stage_get_all_for_list(ctx, list->id, &stages_len);
    if (!task_ctx->stage) {
      klist_print(ctx, KLIST_LOG_ERROR,
                  "Stage missing/wrong, please pass one of: ");
      int i = 0;
      for (; i < stages_len; i++)
        fprintf(ctx->log_target, "%s ", (char *)stages[i]->name);
      fprintf(ctx->log_target, "\n");
    }
    int i = 0;
    ssize_t stage_id = -1;
    for (; i < stages_len; i++)
      if (strcmp((char *)stages[i]->name, task_ctx->stage) == 0)
        stage_id = stages[i]->id;

    if (stage_id == -1) {
      klist_print(ctx, KLIST_LOG_ERROR,
                  "Stage %s not found. Use one of: ", task_ctx->stage);
      i = 0;
      for (; i < stages_len; i++)
        fprintf(ctx->log_target, "%s ", (char *)stages[i]->name);
      fprintf(ctx->log_target, "\n");
    }
    i = 0;
    for (; i < stages_len; i++)
      klist_stage_deinit(stages[i]);
    free(stages);

    klist_task *task =
        klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
    if (!task)
      task = klist_task_init();
    if (task->name)
      free(task->name);
    task->name = (unsigned char *)strdup(task_ctx->name);
    if (task->desc)
      free(task->desc);
    if (task_ctx->desc)
      task->desc = (unsigned char *)strdup(task_ctx->desc);
    task->stage_id = stage_id;
    klist_task_save(ctx, task);
    klist_task_deinit(task);
  } else
    klist_print(ctx, KLIST_LOG_ERROR, "List not found.\n");
  klist_user_deinit(user);
  if (list)
    klist_list_deinit(list);
  return 0;
}

int klist_app_task_get(klist *ctx) {
  klist_task_context *task_ctx = ctx->cmd_ctx;
  klist_assure_user(ctx, getuid(), getlogin());
  klist_user *user = klist_user_get_by_local(ctx, getuid());
  if (!user) {
    klist_print(ctx, KLIST_LOG_ERROR, "User doesn't exist.\n");
    return 1;
  }
  klist_list *list =
      klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
  if (list) {
    if (task_ctx->name) {
      klist_task *task =
          klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
      if (task) {
        printf("Name: %s\n", (char *)task->name);
        printf("Description: %s\n", task->desc ? (char *)task->desc : "N/A");
        klist_stage *stage = klist_stage_get_by_id(ctx, task->stage_id);
        printf("Stage: %s\n", (char *)stage->name);
        klist_stage_deinit(stage);
        klist_task_deinit(task);
      } else
        klist_print(ctx, KLIST_LOG_ERROR, "Task not found.\n");
    } else {
      size_t tasks_len = 0;
      klist_task **tasks = klist_task_get_for_list(ctx, list->id, &tasks_len);
      klist_print_list(ctx, list, tasks, tasks_len);

      int i = 0;
      for (; i < tasks_len; i++)
        klist_task_deinit(tasks[i]);
      free(tasks);
    }
  } else
    klist_print(ctx, KLIST_LOG_ERROR, "list not found\n");
  klist_user_deinit(user);
  if (list)
    klist_list_deinit(list);
  return 0;
}

int klist_app_task_delete(klist *ctx) {
  klist_task_context *task_ctx = ctx->cmd_ctx;
  klist_assure_user(ctx, getuid(), getlogin());
  klist_user *user = klist_user_get_by_local(ctx, getuid());
  if (!user) {
    klist_print(ctx, KLIST_LOG_ERROR, "User doesn't exist.\n");
    return 1;
  }
  klist_list *list =
      klist_list_get_by_user_and_name(ctx, user->id, task_ctx->list);
  if (list) {
    if (task_ctx) {
      klist_task *task =
          klist_task_get_for_list_by_name(ctx, list->id, task_ctx->name);
      if (task) {
        klist_print(ctx, KLIST_LOG_WARNING, "Deleting task '%s'.\n",
                    (char *)task->name);
        klist_task_delete(ctx, task);
        klist_task_deinit(task);
      } else
        klist_print(ctx, KLIST_LOG_ERROR, "Task not found.\n");
    } else
      klist_print(ctx, KLIST_LOG_ERROR,
                  "Task not found, only deletion by name is "
                  "currently supoprted.\n");
  } else
    klist_print(ctx, KLIST_LOG_ERROR, "Not implemented\n");
  return 0;
}