const {
  getUserFromIdService
} = require("../services/UserService");

const {
  JwtVerify
} = require("../services/JwtService");

const {
  getAllEventsService,
  getEventFromIdService,
  alterUserSubscribedEventStateService,
  getUserSubscribedEventService, createEventService, editEventService, deleteEventService
} = require("../services/EventService");

const {Logger} = require('tslog')
const logger = new Logger({ name: "Event Controller" });

//TODO - To test
/**
 * Retrieves all events.
 *
 * @param {Object} req - The request object.
 * @param {Object} res - The response object.
 * @return {Object} The response object containing all events or an error message if events not found.
 */
async function getAllEvents(req, res) {
  const events = await getAllEventsService('public');
  if (!events) {
    return res.status(404).json({ message: "Events not found" });
  }
  return res.status(200).json(events);
}

//TODO - To test
/**
 * Retrieves an event by ID.
 *
 * @param {object} req - The request object.
 * @param {object} res - The response object.
 *
 * @return {object} Returns a response with the retrieved event.
 *
 * @throws {Error} Throws an error if the event ID is missing or if the event is not found.
 */
async function getEvent(req, res) {
  const authHeader = req.headers.authorization;
  const bearerToken = authHeader.split(' ')[1];
  const payload = await JwtVerify(bearerToken);
  const sourceUser = await getUserFromIdService(payload.sub)
  const targetId = req.params.id;
  if (!targetId) {
    return res.status(400).json({ message: "Event ID is missing" });
  }
  const result = await getEventFromIdService(targetId)
  if (!result) {
    return res.status(404).json({ message: "Event not found" });
  }
  return res.status(200).json(result);
}

//TODO Get owned event

//TODO - To test
async function editEvent(req, res) {
  const body = req.body;
  const authHeader = req.headers.authorization;
  const bearerToken = authHeader.split(' ')[1];
  const payload = await JwtVerify(bearerToken);
  const sourceUser = await getUserFromIdService(payload.sub)
  const targetId = body.targetId || sourceUser.id;
  const eventTargetId = req.params.id
  if (targetId !== sourceUser.id && !sourceUser.isAdmin) {
    res.status(403).json({ message: "Unauthorized request" });
  }
  if (!eventTargetId) {
    res.status(400).json({ message: "Event target ID is missing" });
  }
  // biome-ignore lint/style/useConst: <explanation>
  let modifiedData= {}
  if (body.title) modifiedData.title = `${body.title}`;
  if (body.subTitle) modifiedData.subTitle = `${body.subTitle}`;
  if (body.base64Banner) modifiedData.base64Banner = `${body.base64Banner}`;
  if (body.desc) modifiedData.desc = `${body.desc}`;
  if (body.date) modifiedData.date = `${body.date}`;
  if (body.were) modifiedData.were = `${body.were}`;
  if (body.maxMembers) modifiedData.maxMembers = `${body.maxMembers}`;

  const editEventResult = await editEventService(`${eventTargetId}`, modifiedData);

  if (editEventResult.error === 'eventNotFound') {
      return res.status(500).json({
        error: 'editFailed',
        message: 'Failed to edit event'
      });
  }
  return res.status(200).json({
      message: "Event edited successfully"
  });
}

//TODO - To test
async function deleteEvent(req, res) {
  const authHeader = req.headers.authorization;
  const bearerToken = authHeader.split(' ')[1];
  const payload = await JwtVerify(bearerToken);
  const sourceUser = await getUserFromIdService(payload.sub)
  const eventId = req.params.id;
  if (!eventId) {
    res.status(400).json({ message: "Event ID is missing" });
  }
  const Event = getEventFromIdService(eventId)
  if (!Event) {
    return res.status(404).json({ message: "Event not found" });
  }
  if (Event.authorId !== sourceUser.id && !sourceUser.isAdmin) {
    return res.status(403).json({ message: "Unauthorized request" });
  }
  const deleteEventResult = await deleteEventService(Event.id)
  if (!deleteEventResult) {
      return res.status(500).json({
          error: 'deleteFailed',
          message: 'Failed to delete event'
      });
  }
  return res.status(200).json({
      message: "Event deleted successfully"
  });
}

//TODO - To test
async function createNewEvent(req, res) {
  const body = req.body;
  if (!body.title || !body.subTitle || !body.base64Banner || !body.desc || !body.date || !body.were || !body.maxMembers) {
    logger.warn(`Field(s) missing (${req.ip})`);
    return res
      .type('application/json')
      .status(400)
      .json({ error: 'Field(s) missing' });
  }
  const authHeader = req.headers.authorization;
  const bearerToken = authHeader.split(' ')[1];
  const payload = await JwtVerify(bearerToken);
  const sourceUser = await getUserFromIdService(payload.sub);
  const targetUserId = body.authorId || sourceUser.id
  if (targetUserId !== sourceUser.id && !sourceUser.isAdmin) {
    return res.status(403).json({
      error: "unauthorized",
      message: "Unauthorized request"
    });
  }

  // biome-ignore lint/style/useConst: <explanation>
  let sanitizedData= {}
  if (body.title) sanitizedData.title = `${body.title}`;
  if (body.subTitle) sanitizedData.subTitle = `${body.subTitle}`;
  if (body.base64Banner) sanitizedData.base64Banner = `${body.base64Banner}`;
  if (body.desc) sanitizedData.desc = `${body.desc}`;
  if (body.date) sanitizedData.date = `${body.date}`;
  if (body.were) sanitizedData.were = `${body.were}`;
  if (body.maxMembers) sanitizedData.maxMembers = `${body.maxMembers}`;

  const createdEventResult = await createEventService(targetUserId, sanitizedData)

  if (createdEventResult.error === 'createFailed') {
    return res.status(500).json({
      error: 'createFailed',
      message: 'Failed to create event'
    });
  }
  return res.status(200).json(createdEventResult.eventId);
}

/**
 * Retrieves the subscribed event for the specified user.
 *
 * @param {Object} req - The request object.
 * @param {Object} res - The response object.
 * @returns {Object} The subscribed event information.
 */
async function getSubscribedEvent(req, res) {
  const authHeader = req.headers.authorization;
  const bearerToken = authHeader.split(' ')[1];
  const payload = await JwtVerify(bearerToken);
  const sourceUser = await getUserFromIdService(payload.sub)
  const subscribedEventResult = await getUserSubscribedEventService(sourceUser.id);
  if (subscribedEventResult.error === 'noSubscribedEventFound') {
    return res
      .type('application/json')
      .status(404)
      .json({
        error: 'noSubscribedEventFound',
        message: 'No subscribed event found'
    });
  }
  return res
    .type('application/json')
    .status(200)
    .json(subscribedEventResult);
}

//TODO - To test
/**
 * Alter the subscription state of an event for a user.
 * @param {Object} req
 *                      - The request object.
 * @param {Object} req.body
 *                      - The body of the request containing the desired subscription state.
 * @param {string} req.headers.authorization
 *                      - The authorization header containing the bearer token.
 * @param {string} req.params.id
 *                      - The ID of the target event.
 * @param {Object} res
 *                      - The response object.
 * @returns {Object} The response object.
 */
async function alterSubscribedEventState(req, res) {
  const body = req.body
  const authHeader = req.headers.authorization;
  const bearerToken = authHeader.split(' ')[1];
  const payload = await JwtVerify(bearerToken);
  const sourceUser = await getUserFromIdService(payload.sub)
  const eventTargetId = req.params.id;
  const userTargetId = body.userId || sourceUser.id
  const wantedState = body.subscribed === true
  if (!eventTargetId) {
    return res.status(400).json({ message: "Event target ID is missing" });
  }
  if (userTargetId !== sourceUser.id && !sourceUser.isAdmin) {
    return res.status(403).json({ message: "Unauthorized request" });
  }

  const alterEventSubStateResult = await alterUserSubscribedEventStateService(
    userTargetId,
    eventTargetId,
    wantedState
  )

  if (alterEventSubStateResult.error === 'none') {
    return res.status(200).json({
      message: "Event subscription state altered"
    });
  }
  return res.status(400).json({
    error: alterEventSubStateResult.error,
    message: "Event subscription state not altered"
  });
}

module.exports = {
  getAllEvent: getAllEvents,
  getEvent,
  editEvent,
  deleteEvent,
  createNewEvent,
  getSubscribedEvent,
  alterSubscribedEventState
}