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

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

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

//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 Owner user, admin user             ===
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" });
  }

}

//TODO Owner user, admin user             ===
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)
}

//TODO Event creation by logged user      ===
async function createNewEvent(req, res) {
  const authHeader = req.headers.authorization;
  const bearerToken = authHeader.split(' ')[1];
  const payload = await JwtVerify(bearerToken);
  const sourceUser = await getUserFromIdService(payload.sub)
}

//TODO - To test
/**
 * 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 targetId = body.targetId || sourceUser.id;
  if (targetId !== sourceUser.id && !sourceUser.isAdmin) {
    res.status(403).json({ message: "Unauthorized request" });
  }
  const subscribedEventResult = await getUserSubscribedEventService(targetId);
  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
}