const { Fragment } = require('../../model/fragment');
const logger = require('../../logger');
const mime = require('mime-types');
const path = require('node:path');

const {createErrorResponse} = require('../../response');
/**
 * Gets an authenticated user's fragment data with the given ID
 */
function validConversion(contentType, extension) {
	let validFormats = [];

	switch (contentType) {
	  case 'text/plain':
		validFormats = ['.txt']; break;
	  case 'text/markdown': 
	  	validFormats = ['.md', '.html', '.txt']; break;
	  case 'text/html': 
	  	validFormats = ['.html', '.txt']; break;
	  case 'application/json':
		validFormats = ['.json', '.txt']; break;
	  case 'image/png':
		validFormats = ['.png', '.jpeg', '.webp', '.gif'];
		break;
	  case 'image/jpeg':
		validFormats = ['.png', '.jpeg', '.webp', '.gif'];
		break;
	  case 'image/webp':
		validFormats = ['.png', '.jpeg', '.webp', '.gif'];
		break;
	  case 'image/gif':
		validFormats = ['.png', '.jpeg', '.webp', '.gif'];
		break;
	  default:
		return false;
	}

	const result = validFormats.includes(extension);

  	return result;
}

module.exports = async (req, res) => {
	let fragmentById;
	let fragmentData;
	try {
		const fragmentID = req.params.id.split('.')[0];
		const extension = req.params.id ? path.extname(req.params.id) : '';

		logger.debug(`extension123: ${extension}`);
		fragmentById = new Fragment(await Fragment.byId(req.user, fragmentID));
		

		fragmentData = await fragmentById.getData();

		const convertType = mime.lookup(extension);
		logger.debug(`Convert Type before conversion: ${fragmentById.mimeType}`);
		

		if(!convertType && extension){
			return res
					.status(415)
					.json(createErrorResponse(
							415, 
							`type is invalid`
						)
					);
		}
	
		else if(!convertType){
			logger.info("sucessfully get the fragment data by id with no type");
			//const rawData = Buffer.from(fragmentData.toString());

			// Set headers
			res.setHeader('Content-type', fragmentById.type);
			
			res.status(200).send(fragmentData);
		
		}
		else{
			if(!validConversion(fragmentById.mimeType, extension)){
				logger.debug('convert type is not include in convertable formats');
				return res
					.status(415)
					.json(createErrorResponse(
							415, 
							`Fragment extension is not unsupported type`
						)
					);
			}
			//logger.debug(`fragmentData: ${fragmentData}`);
			logger.info("sucessfully get the fragment data by id with type");
			
			const result = await fragmentById.convertData(fragmentData, extension, convertType)
				
			logger.debug(`Converted-Type: ${convertType}`);
			res.setHeader('Content-type', convertType);
			//logger.debug(`fragmentData after convert: ${fragmentData}`);	
		    res.status(200).send(result);						
		}		
	} catch (err) {
		logger.error("GET /fragments/:id ERROR");
		res.status(404).json(createErrorResponse(404, err.message));
	}
};