import { Response, NextFunction } from 'express';
// import { DeleteFile } from '../utils/deletingFile';
import { ErrorResponse, SuccessResponse } from '../utils/Response';
import { HttpCodes } from '../config/Errors';
import { globalLogger } from '../utils/Logger';
import { MyRequest } from '../types/Express';
import {
  deleteFile,
  deleteFileThumbnail,
} from '../middlewares/file.middleware';
import {
  uploadThumbnailToCloudinary,
  getThumbnailPublicId,
  deleteThumbnailFromCloudinary,
} from '../utils/UploadToCloudinary';

export async function handleFileUploading(
  req: MyRequest<UserI>,
  res: Response,
  next: NextFunction
): Promise<void> {
  try {
    if (!req.file)
      return ErrorResponse(
        res,
        HttpCodes.BadRequest.code,
        'No file uploaded',
        'No file uploaded'
      );
    const fileUrl = req.file;
    const filename = fileUrl.filename;

    // log first File uploaded - file name
    globalLogger.info(`File uploaded - ${filename}`, {
      code: HttpCodes.Accepted.code,
      type: HttpCodes.Accepted.type,
      file: fileUrl,
    });
    return SuccessResponse(
      res,
      HttpCodes.Accepted.code,
      {
        name: fileUrl.filename,
        originalname: fileUrl.originalname,
        size: fileUrl.size,
        url: `${req.protocol}://${req.get('host')}/documents/${
          fileUrl.filename
        }`,
      },
      `File ${fileUrl.originalname} has been uploaded`
    );
  } catch (error) {
    globalLogger.error('Error while uploading file', {
      code: HttpCodes.InternalServerError.code,
      type: HttpCodes.InternalServerError.type,
      error: error,
    });

    return ErrorResponse(
      res,
      HttpCodes.InternalServerError.code,
      'Error while uploading file',
      error
    );
  }
}

export async function handleFileDeleting(
  req: MyRequest<UserI>,
  res: Response,
  next: NextFunction
): Promise<void> {
  try {
    if (!req.query.file)
      return ErrorResponse(
        res,
        HttpCodes.BadRequest.code,
        'No file to delete',
        'No file to delete'
      );
    const file = req.query.file as string;
    const result = await deleteFile(file);
    if (result instanceof Error) {
      globalLogger.error('Error while deleting file', {
        code: HttpCodes.InternalServerError.code,
        type: HttpCodes.InternalServerError.type,
        error: result,
      });

      return ErrorResponse(
        res,
        HttpCodes.InternalServerError.code,
        'Error while deleting file',
        result
      );
    }
    return SuccessResponse(
      res,
      HttpCodes.Accepted.code,
      {},
      `File ${file} has been deleted`
    );
  } catch (error) {
    globalLogger.error('Error while deleting file', {
      code: HttpCodes.InternalServerError.code,
      type: HttpCodes.InternalServerError.type,
      error: error,
    });

    return ErrorResponse(
      res,
      HttpCodes.InternalServerError.code,
      'Error while deleting file',
      error
    );
  }
}

export async function handleFileGetting(
  req: MyRequest<UserI>,
  res: Response,
  next: NextFunction
): Promise<void> {
  try {
    if (!req.query.file)
      return ErrorResponse(
        res,
        HttpCodes.BadRequest.code,
        'No file to get',
        'No file to get'
      );
    const file = req.query.file as string;
    return res.download(`uploads/documents/${file}`, file, (error) => {
      if (error) {
        globalLogger.error('Error while getting file', {
          code: HttpCodes.InternalServerError.code,
          type: HttpCodes.InternalServerError.type,
          error: error,
        });

        return ErrorResponse(
          res,
          HttpCodes.InternalServerError.code,
          'Error while getting file',
          error
        );
      }
    });
  } catch (error) {
    globalLogger.error('Error while getting file', {
      code: HttpCodes.InternalServerError.code,
      type: HttpCodes.InternalServerError.type,
      error: error,
    });

    return ErrorResponse(
      res,
      HttpCodes.InternalServerError.code,
      'Error while getting file',
      error
    );
  }
}

export async function handleFileThumbnailUploading(
  req: MyRequest<UserI>,
  res: Response,
  next: NextFunction
): Promise<void> {
  try {
    if (!req.file)
      return ErrorResponse(
        res,
        HttpCodes.BadRequest.code,
        'No file uploaded',
        'No file uploaded'
      );
    const file = req.file;
    const filename = file.filename;
    const fileUrl = await uploadThumbnailToCloudinary(filename);
    globalLogger.info(`File uploaded - ${filename}`, {
      code: HttpCodes.Accepted.code,
      type: HttpCodes.Accepted.type,
      file: file,
    });
    return SuccessResponse(
      res,
      HttpCodes.Accepted.code,
      {
        fileUrl,
      },
      `File ${file.originalname} has been uploaded`
    );
  } catch (error) {
    globalLogger.error('Error while uploading file', {
      code: HttpCodes.InternalServerError.code,
      type: HttpCodes.InternalServerError.type,
      error: error,
    });

    return ErrorResponse(
      res,
      HttpCodes.InternalServerError.code,
      'Error while uploading file',
      error
    );
  }
}

export async function handleFileThumbnailDeleting(
  req: MyRequest<UserI>,
  res: Response,
  next: NextFunction
): Promise<void> {
  try {
    if (!req.query.file)
      return ErrorResponse(
        res,
        HttpCodes.BadRequest.code,
        'No file to delete',
        'No file to delete'
      );
    const fileUrl = req.query.file as string;
    const publicId = getThumbnailPublicId(fileUrl);
    const result: any = await deleteThumbnailFromCloudinary(publicId);

    if (result instanceof Error) {
      globalLogger.error('Error while deleting file', {
        code: HttpCodes.InternalServerError.code,
        type: HttpCodes.InternalServerError.type,
        error: result,
      });

      return ErrorResponse(
        res,
        HttpCodes.InternalServerError.code,
        'Error while deleting file',
        result
      );
    }
    globalLogger.info(`File deleted - ${publicId}`, {
      code: HttpCodes.Accepted.code,
      type: HttpCodes.Accepted.type,
    });
    return SuccessResponse(
      res,
      HttpCodes.Accepted.code,
      {},
      `File ${publicId} has been deleted`
    );
  } catch (error) {
    globalLogger.error('Error while deleting file', {
      code: HttpCodes.InternalServerError.code,
      type: HttpCodes.InternalServerError.type,
      error: error,
    });

    return ErrorResponse(
      res,
      HttpCodes.InternalServerError.code,
      'Error while deleting file',
      error
    );
  }
}