const express = require("express");
const _ = require("lodash");
const requester = require("../../helper/requester");
const socket = require("../../socket.js");
const events = require("../../model/events");
const errorCodes = require("../../helper/errorcodes");
const dbHelper = require("../../db/db_helper");
const USER_TYPES = require("../../model/roles");
const parser = require("../../helper/parser");
const myErrors = require("../../helper/errorcodes");
const myConstants = require("../../helper/connstants");
const dbWorker = require("../../db-worker");

const router = express.Router();

router
  .route("/")
  .post(billing, createTask)
  .get(getMyTasks);

router.route("/:id/read").patch(setTaskIsRead);

router.route("/:id/close").patch(closeTask);

router.route("/edit/:id").post(editTask);

router.route("/find").post(findTask);

router.route("/open/:id").get(openTask);

async function billing(req, res, next) {
  if (req.user.role === USER_TYPES.GUEST) {
    try {
      let tasks = await dbHelper.getMyTasks(req.user.id);
      if (tasks.length >= myConstants.MAX_CREATE_ENTITY_COUNT) {
        return res.json(requester.createError(errorCodes.BILLING_ERROR));
      }
    } catch (e) {
      console.error(e);
      return res.json(requester.createError());
    }
  }
  return next();
}

//  Создать заявку
async function createTask(req, res, next) {
  const task = req.body;
  const userId = req.user.id;
  const userName = req.user.name;

  let body;
  try {
    const badWords = await dbHelper.checkBadWords(task.body);
    if (!badWords) {
      const dbNewTask = await dbHelper.createTask(userId, task);
      const avatar = await dbHelper.getAvatar(userId);
      const uuid = avatar ? avatar.uuid : null;
      dbNewTask.name = userName;
      dbNewTask.uuid = uuid;
      const newTask = parser.parseTask(dbNewTask);

      const dbSubscribers = await dbHelper.getSubscribers(userId, newTask.id);
      if (dbSubscribers.length > 0) {
        const dbFoundTask = _.cloneDeep(dbNewTask);
        dbFoundTask.is_read = false;
        const FoundTask = parser.parseFoundTask(dbFoundTask);
        const ids = parser.parseSubIdsFromSubscribers(dbSubscribers);
        await dbHelper.addSubscribedTask(FoundTask.id, ids);

        //  Отправляем заявку подписчикам
        for (el of dbSubscribers) {
          console.log(
            "Пересылаем заявку",
            FoundTask.id,
            " пользователю ",
            el.user_id
          );
          socket.sendData(userId, el.user_id, events.TASK, {
            data: FoundTask,
            subscriptions: el.subscriptions
          });
        }
      }
      body = requester.createBody({ id: newTask.id });
    } else {
      console.log("Найдены плохие слова", badWords);
      body = requester.createError(errorCodes.BAD_WORDS, badWords);
    }
  } catch (error) {
    console.error(error);
    body = requester.createError(error);
  }
  res.json(body);
}

//Закрыть заявку
async function closeTask(req, res, next) {
  const taskId = parseInt(req.path.split("/")[1], 10);
  const userId = req.user.id;

  let body;
  try {
    await dbHelper.closeTask(userId, taskId);
    const dbTask = await dbHelper.getTaskById(taskId);
    const task = parser.parseTask(dbTask);
    await dbWorker.closeFoundTasks([task]);
    body = requester.createBody();
  } catch (error) {
    console.error(error);
    body = requester.createError(error);
  }
  res.json(body);
}

// Открыть заявку
async function openTask(req, res, next) {
  const taskId = req.params.id;
  const userId = req.user.id;

  let body;
  try {
    await dbHelper.openTask(userId, taskId);
    body = requester.createBody();
  } catch (error) {
    console.error(error);
    body = requester.createError(error);
  }
  res.json(body);
}

//  Поиск всех моих заявок
async function getMyTasks(req, res, next) {
  const userId = req.user.id;
  let body;
  try {
    const dbTasks = await dbHelper.getMyTasks(userId);
    const myTasks = dbTasks.map(el => parser.parseTask(el));
    body = requester.createBody(myTasks);
  } catch (error) {
    console.error(error);
    body = requester.createError(error);
  }
  res.json(body);
}

//  Поиск заявок в радиусе
async function findTask(req, res, next) {
  const userId = req.user.id;
  const position = req.body.position;
  const coordinates = position.coordinates;
  const radius = position.radius;
  const tags = req.body.tags;
  let body;
  try {
    console.log("Ищем заявки ", userId);

    const badWords = await dbHelper.checkBadWords(tags.join(","));
    if (!badWords) {
      const dbTasks = await dbHelper.findTasks(
        userId,
        coordinates,
        radius,
        tags
      );
      const foundTasks = dbTasks.map(el => parser.parseFoundTask(el));
      body = requester.createBody(foundTasks);
    } else {
      console.log("Найдены плохие слова", badWords);
      body = requester.createError(errorCodes.BAD_WORDS, badWords);
    }
  } catch (error) {
    console.error(error);
    body = requester.createError(error);
  }
  res.json(body);
}

// Редактировать заявку
async function editTask(req, res, next) {
  console.log("editTask", req.body.id);
  const userId = req.user.id;
  const task = req.body;
  let body;
  try {
    const badWords = await dbHelper.checkBadWords(task.body);
    if (!badWords) {
      await dbHelper.editTask(userId, task);
      body = requester.createBody();
    } else {
      console.log("Найдены плохие слова", badWords);
      body = requester.createError(errorCodes.BAD_WORDS, badWords);
    }
  } catch (error) {
    console.error(error);
    body = requester.createError(error);
  }
  res.json(body);
}

// Просмотрели заявку
async function setTaskIsRead(req, res) {
  const taskId = req.params.id;
  const userId = req.user.id;
  let body;
  try {
    await dbHelper.setTaskIsRead(userId, taskId);
    body = requester.createBody();
  } catch (error) {
    console.error("setTaskIsRead", userId, taskId, error);
    body = requester.createError(myErrors.SET_TASK_IS_READ);
  }
  res.json(body);
}

module.exports = router;