'use server'

import { API_BASE_URL } from '@/app/actions/definitions';
import { getSessionData } from '@/app/actions/session';
import { FormState } from '@/app/actions/auth';
import { unknown } from 'zod';

interface initMessageBody {
	file_name: string,
	file_type: string,
	extension: string,
	file_size: number | string,
	action?: string,
	token?: string,
	convertTo?: string | undefined | null
}

export async function fileUpload(messageBody: initMessageBody, convertTo?: string | null | undefined) {
	const token = await getSessionData('token');
	if (!token) {
		return;
	}
	const message = messageBody;
	message.action = 'init';
	message.token = token;

	if (convertTo && convertTo !== 'reject') {
		message.convertTo = convertTo;
	}

	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20004,
				message_body: message
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json() as {
				message_desc: string,
				message_body: {
					upload_id: string,
					total_chunks: number,
					chunk_size: number,
					status: string
				},
				message_code: string
			};

			if (parsed.message_desc === 'Operation successful') {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}
	} catch (error) {
		return error;
	}
}

export async function cancelUpload(udloadId: string) {
	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20004,
				message_body: {
					action: 'cancel',
					upload_id: udloadId,
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json() as {
				message_code: string,
				message_desc: string,
				message_body: {
					upload_id: string,
					message: string
				}
			};

			if (parsed.message_desc === 'Upload cancelled successfully') {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}
	} catch (error) {
		return error;
	}
}

export type ChunkResponse = {
	errorMesage: string | null
	fileId?: string
};

export async function chunkUpload(formData: FormData, itPrivate?: boolean): Promise<ChunkResponse> {
	console.log('chunkUpload');
	const token = await getSessionData('token');

	try {
		const url = itPrivate
			? `${API_BASE_URL}/api/v1/private/files/chunk`
			: `${API_BASE_URL}/api/v1/files/chunk`;


		if (token && itPrivate) {
			formData.append('token', token);
		}

		const response = await fetch(url, {
			method: 'POST',
			body: formData
		});

		if (response.ok) {
			let parsed = await response.json();
			console.log(formData);
			console.log(parsed);

			if (parsed.message_code === 0) {
				return {
					errorMesage: null,
					fileId: parsed.message_body.file_id
				}
			} else if (parsed.message_desc === 'Duplicate file upload') {
				throw 'error-duplicate-file'
			} else if (parsed.message_desc === 'Failed to upload chunk: Failed to upload chunk: User not have tokens for protect') {
				throw 'user-not-have-tokens-for-protect'
			} else if (parsed.message_desc === 'Failed to upload chunk: Failed to upload chunk: Failed to upload chunk: .wav file not have RIFF header') {
				throw 'error-upload-chunk-wav-file-not-have-riff'
			} else {
				throw 'error-uploading-file'
			}
		} else {
			throw 'error-uploading-file'
		}
	} catch (error: unknown) {
		if (error) {
			const typedError = error as string;

			return {
				errorMesage: typedError
			};
		} else {
			return {
				errorMesage: 'error-uploading-file'
			};
		}

	}
}

export async function checkChunkStatus(upload_id: string) {
	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20004,
				message_body: {
					action: 'chunks',
					upload_id
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json();

			if (parsed.message_desc === 'Upload cancelled successfully') {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error) {
		return error
	}
}

export async function getAllowedFilesExtensions(type: string) {
	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 20004,
				message_body: {
					action: 'file_extension',
					file_type: type
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json();

			if (parsed.message_desc === 'Operation successful') {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error) {
		return error
	}
}

export async function checkOperationPrice(action: string, filesCount: number, fileType: string) {
	const token = await getSessionData('token');

	try {
		const response = await fetch(`${API_BASE_URL}/api/v1/data`, {
			method: 'POST',
			body: JSON.stringify({
				version: 1,
				msg_id: 30008,
				message_body: {
					auth_token: token,
					action: action,
					file_type: fileType,
					count_files: filesCount
				}
			}),
			headers: {
				'Content-Type': 'application/json',
				'Accept': 'application/json'
			}
		});

		if (response.ok) {
			let parsed = await response.json();

			if (parsed.message_code === 0) {
				return parsed.message_body;
			} else {
				throw parsed;
			}
		} else {
			throw (`${response.status}`);
		}

	} catch (error) {
		return {
			cost: 0,
			success: false,
			tokens_count: 0,
			error: 'error'
		}
	}
}