import { Request, Response } from 'express';
import { AppError } from '../errors/app-error';
import {
  getDashboardResponsable,
  listerAnomaliesResponsable,
  listerNotificationsResponsable,
  listerMaterielsResponsable,
  listerEmpruntsResponsable,
  marquerNotificationResponsableLue,
  marquerToutesNotificationsResponsableLues,
  parseCategorieId,
  parseLu,
  parseNotificationId,
  parseStatutAnomalie,
  parseStatutMateriel,
  parseStatutEmprunt,
} from '../services/responsable.service';
import {
  toAnomalieResponsableResponse,
  toDashboardResponsableResponse,
  toEmpruntResponsableResponse,
  toMaterielResponsableResponse,
  toNotificationResponsableResponse,
} from '../dtos/responsable.dto';

export async function getDashboard(req: Request, res: Response): Promise<void> {
  const user = req.user;
  if (!user) {
    throw new AppError(401, 'Authentification requise');
  }

  const dashboard = await getDashboardResponsable(user.id, user.roleCode, user.campusId);
  res.json({ data: toDashboardResponsableResponse(dashboard) });
}

export async function getEmprunts(req: Request, res: Response): Promise<void> {
  const user = req.user;
  if (!user) {
    throw new AppError(401, 'Authentification requise');
  }

  const statut = parseStatutEmprunt(req.query.statut);
  const emprunts = await listerEmpruntsResponsable(user.roleCode, user.campusId, { statut });
  res.json({ data: emprunts.map(toEmpruntResponsableResponse) });
}

export async function getMateriels(req: Request, res: Response): Promise<void> {
  const user = req.user;
  if (!user) {
    throw new AppError(401, 'Authentification requise');
  }

  const statut = parseStatutMateriel(req.query.statut);
  const categorieId = parseCategorieId(req.query.categorieId);
  const recherche = typeof req.query.q === 'string' ? req.query.q : undefined;

  const materiels = await listerMaterielsResponsable(user.roleCode, user.campusId, {
    statut,
    categorieId,
    recherche,
  });
  res.json({ data: materiels.map(toMaterielResponsableResponse) });
}

export async function getAnomalies(req: Request, res: Response): Promise<void> {
  const user = req.user;
  if (!user) {
    throw new AppError(401, 'Authentification requise');
  }

  const statut = parseStatutAnomalie(req.query.statut);
  const type = typeof req.query.type === 'string' ? req.query.type : undefined;

  const anomalies = await listerAnomaliesResponsable(user.roleCode, user.campusId, {
    statut,
    type,
  });
  res.json({ data: anomalies.map(toAnomalieResponsableResponse) });
}

export async function getNotifications(req: Request, res: Response): Promise<void> {
  const user = req.user;
  if (!user) {
    throw new AppError(401, 'Authentification requise');
  }

  const lu = parseLu(req.query.lu);
  const notifications = await listerNotificationsResponsable(user.id, user.roleCode, { lu });
  res.json({ data: notifications.map(toNotificationResponsableResponse) });
}

export async function patchNotificationLue(req: Request, res: Response): Promise<void> {
  const user = req.user;
  if (!user) {
    throw new AppError(401, 'Authentification requise');
  }

  const notificationId = parseNotificationId(req.params.id);
  const notification = await marquerNotificationResponsableLue(
    user.id,
    user.roleCode,
    notificationId,
  );
  res.json({ data: toNotificationResponsableResponse(notification) });
}

export async function patchNotificationsLues(req: Request, res: Response): Promise<void> {
  const user = req.user;
  if (!user) {
    throw new AppError(401, 'Authentification requise');
  }

  const count = await marquerToutesNotificationsResponsableLues(user.id, user.roleCode);
  res.json({ data: { count } });
}