import type { IDbCategory } from "@interfaces/database/IDbCategory";
import MysqlService from "@services/mysql.service";
import {Logger} from "tslog";
import { v4 as uuidv4 } from 'uuid';

const DbHandler = new MysqlService.Handler('CategoryService')
const logger = new Logger({name: 'CategoryService'})



/**
 * Creates a new category with the given data.
 *
 * @param {IDbCategory} data - The category data.
 * @returns {Promise<boolean>} A promise that resolves with the created category.
 *                            If an error occurs, the promise will reject with the error.
 */
async function createCategory(data: IDbCategory): Promise<boolean> {
	logger.info(`Creating a new category... (${data.display_name})`)
	try {
		await MysqlService.Category.insert(DbHandler, {
			id: uuidv4(),
			display_name: data.display_name,
			slug_name: data.slug_name
		})
		//TODO Return the new id
		return true;
	} catch (error) {
		logger.error(`Error creating category: ${error}`);
    return false;
	}
}

/**
 * Update a category in the database.
 *
 * @param {IDbCategory} data - The data of the category to update.
 * @property {number} data.id - The id of the category.
 * @property {string} [data.slug_name] - The slug name of the category.
 * @property {string} [data.display_name] - The display name of the category.
 *
 * @returns {boolean} - Returns true if the category is updated successfully, false otherwise.
 */
async function updateCategory(data: IDbCategory) {
	if (!data.id) {
		logger.error("Category id is missing.")
		return false
	}
	try {
		await MysqlService.Category.update(DbHandler, {
			id: data.id,
			slug_name: data.slug_name,
			display_name: data.display_name
		});
		//TODO Return id
		return true;
	} catch (err) {
		logger.error(err)
		return false;
	}
}

/**
 * Retrieves all categories from the database.
 *
 * @returns {Promise<Array<IDbCategory>> | null} Promise that resolves to an array of IDbCategory objects or null if an error occurred.
 */
async function getAll(): Promise<Promise<Array<IDbCategory>> | null> {
	try {
			logger.info("Getting all categories...");
      return await MysqlService.Category.getAll(DbHandler);
  } catch (error) {
      logger.error(`Error getting all categories: ${error}`);
      return null;
  }
}


/**
 * Gets a category by its slug
 *
 * @param {string} slug - The slug of the category
 * @return {Promise<IDbCategory|null>} - A promise that resolves to the category object or null if not found
 */
async function getBySlug(slug: string): Promise<IDbCategory | null> {
	try {
    logger.info(`Getting category by slug... (${slug})`);
    return await MysqlService.Category.getBySlug(DbHandler, slug);
  } catch (error) {
    logger.error(`Error getting category by slug: ${error}`);
    return null;
  }
}

/**
 * Retrieves a category from the database by its id.
 *
 * @param {string} id - The id of the category to retrieve.
 * @returns {Promise<IDbCategory | null>} - A Promise that resolves with the retrieved category object or null if not found.
 */
async function getById(id: string):Promise<IDbCategory | null> {
	try {
      logger.info(`Getting category by id... (${id})`);
      return await MysqlService.Category.getById(DbHandler, id);
    } catch (error) {
      logger.error(`Error getting category by id: ${error}`);
      return null;
    }
}

//FEAT Get all models in category (slug)


/**
 * Deletes a category with the given ID from the database.
 *
 * @param {string} id - The ID of the category to delete.
 * @return {Promise} - A Promise that resolves to the deleted category if successful, or null if an error occurs.
 */
async function deleteCategory(id:string): Promise<unknown> {
	try {
      logger.info(`Deleting category... (${id})`);
      return await MysqlService.Category.delete(DbHandler, id);
  } catch (error) {
      logger.error(`Error deleting category: ${error}`);
      return null;
  }
}

const CategoryService = {
	create: createCategory,
	delete: deleteCategory,
	update: updateCategory,
	getAll,
	getBySlug,
	getById
}

export default CategoryService;