import { fail } from '@sveltejs/kit';
import { BUCKET, client, CONFIGFILENAME, TOKENFILENAME } from '$lib/minio';
import { checkIfExactDirectoryExists, getContentOfTextObject } from './s3ClientService';

import { db } from './dbService';

/**
 * Get Vorgang and corresponend list of tatorte
 * @param vorgangToken
 * @returns
 */
export const getCrimesListByToken = async (vorgangToken: string) => {
	const prefix = `${vorgangToken}/`;

	const stream = client.listObjectsV2(BUCKET, prefix, false, '');

	const list = [];
	for await (const chunk of stream) {
		const splittedNameParts = chunk.name.split('/');
		const prefix = splittedNameParts[0];
		const name = splittedNameParts[1];

		if (name === CONFIGFILENAME || name === TOKENFILENAME) continue;
		list.push({ ...chunk, name: name, prefix: prefix, show_button: true });
	}
	return list;
};

/**
 * Get Vorgang
 * @param vorgangToken
 * @returns vorgangObj with keys `token`, `name`, `pin` || undefined
 */
export const getVorgangByToken = (vorgangToken: string): {token: string, name:string, pin: string} | undefined => {
	const getVorgangSQLStmt = `SELECT token, name, pin FROM cases WHERE token = ?`;
	const statement = db.prepare(getVorgangSQLStmt);
	const result = statement.get(vorgangToken) as {token: string, name:string, pin: string} | undefined;

	return result;
};

/**
 * Get Vorgang
 * @param vorgangName
 * @returns vorgangObj with keys `token`, `name`, `pin` || undefined
 */
export const getVorgangByName = (vorgangName: string): {token: string, name: string, pin: string} | undefined => {
	const getVorgangByNameSQLStmt = `SELECT token, name, pin FROM cases WHERE name = ?`;
	const statement = db.prepare(getVorgangByNameSQLStmt);
	const result = statement.get(vorgangName) as {token: string, name: string, pin: string} | undefined;

	return result;
};

/**
 * Delete Vorgang
 * @param vorgangToken
 * @returns int: number of changes
 */
export const deleteVorgangByToken = function (vorgangToken: string) {
	const deleteSQLStmt = 'DELETE FROM cases WHERE token = ?';
	const statement = db.prepare(deleteSQLStmt);
	const info = statement.run(vorgangToken);

	return info.changes;
};

/**
 * Fetches list of vorgänge from s3 bucket
 * @returns list of available vorgaenge
 */
export const getListOfVorgänge = async () => {
	const stream = client.listObjectsV2(BUCKET, '', false, '');

	const list = [];
	for await (const chunk of stream) {
		const objPath = `${chunk.prefix}${TOKENFILENAME}`;

		const token = await getContentOfTextObject(BUCKET, objPath);

		const cleanedChunkPrefix = chunk.prefix.replace(/\/$/, '');
		list.push({ name: cleanedChunkPrefix, token: token });
	}
	return list;
};

/**
 * Fetches list of vorgänge from database
 * @returns list with of available vorgaenge
 */
export const getVorgaenge = (): {vorgangToken: string, vorgangName: string, vorgangPIN: string}[] => {
	const getVorgaengeSQLStmt = `SELECT token, name, pin from cases`;
	const statement = db.prepare(getVorgaengeSQLStmt);
	const result = statement.all() as { token: string; name: string; vorgangPIN: string }[];
	const vorgaenge_list: {vorgangToken: string, vorgangName: string, vorgangPIN: string}[] = [];
	for (const resultItem of result) {
		const vorg = { vorgangToken: resultItem.token, vorgangName: resultItem.name, vorgangPIN: resultItem.vorgangPIN };
		vorgaenge_list.push(vorg);
	}

	return vorgaenge_list;
};

/**
 * Checks if Vorgang exists
 * @param request
 * @returns fail or true
 */
export const checkIfVorgangExists = async (vorgangId: string | null) => {
	if (!vorgangId) {
		return fail(400, {
			success: false,
			vorgangId,
			error: { message: 'Die Vorgangsnummer darf nicht leer sein.' }
		});
	}

	if (typeof vorgangId === 'string' && !(await checkIfExactDirectoryExists(vorgangId))) {
		return fail(400, {
			success: false,
			vorgangId,
			error: { message: 'Die Vorgangsnummer existiert in dieser Anwendung nicht.' }
		});
	}

	return true;
};

export const vorgangExists = function (vorgangToken: string | null) {
	if (!vorgangToken) {
		return fail(400, {
			success: false,
			vorgangId: vorgangToken,
			error: { message: 'Die Vorgangsnummer darf nicht leer sein.' }
		});
	}

	const vorgaenge = getVorgaenge();
	const vorgaengeTokens = vorgaenge.map((vorgang) => vorgang.vorgangToken);

	const found = vorgaengeTokens.indexOf(vorgangToken) != -1;

	return found;
};

export const vorgangNameExists = function (vorgangName: string) {
	const vorgaenge = getVorgaenge();
	const vorgaengeNames = vorgaenge.map((vorgang) => vorgang.vorgangName);

	const found = vorgaengeNames.indexOf(vorgangName) != -1;

	return found;
};

export const hasValidToken = async (vorgangId: string, vorgangToken: string) => {
	const objPath = `${vorgangId}/${TOKENFILENAME}`;

	try {
		if (!vorgangToken) {
			return false;
		}

		const token = await getContentOfTextObject(BUCKET, objPath);
		if (!token || token !== vorgangToken) {
			return false;
		}

		return true;
	} catch (error) {
		if (error.name == 'S3Error') {
			console.log(error);
			return false;
		}
	}
};

export const vorgangPINValidation = function (vorgangToken: string, vorgangPIN: string) {
	if (!vorgangPIN) {
		return false;
	}

	const vorgang = getVorgangByToken(vorgangToken);

	if (!vorgang || vorgang.pin !== vorgangPIN) {
		return false;
	}

	return true;
};