/* Functions */
import { delayedAlert, isOnline } from './utils'

/* Types */
type Data = Blob | boolean | number | string | undefined

interface Params {
	[key: string]: Data
}

interface BackendRequestOptions {
	errorFunction?: (error: Error) => void
	successFunction?: (content: DelphiContent) => void
	isDev?: boolean
}

interface DelphiContent {
	[key: string]: any
}

interface DelphiResponse {
	content: DelphiContent
	message: string
	success: boolean
}

/* Variables */
var _serverIPAddress = ''

/**
 * @description Função para setar o IP e porta de requisições para o backend do app (remove os espaços do IP)
 * @param url URL do backend
 * @param port Porta do backend
 * @version 1.0.4
 * @since 1.0.0
 */
export function setServerIPAddress(
	url: string,
	port: number | string = 80
): void {
	const trimUrl = url.replace(/\s+/g, '')
	_serverIPAddress = trimUrl ? `${trimUrl}:${port}` : ''
}

/**
 * @description Função para diminuir o código das requisições para o backend
 * @param endpoint Nome do endpoint
 * @param params Parâmetros da requisição
 * @param options Objeto com 3 opções de função successFunction, errorFunction e isDev
 * @example
 * backendRequest('EXEMPLO', {...})
 * return { success: true, content:... }
 * @version 1.0.6
 * @since 1.0.0
 */
export async function backendRequest<T = any>(endpoint: string, params: Params, options?: BackendRequestOptions): Promise<T | void> {
	const { content, message, success } = await serverRequest(endpoint, {
		...params,
		process: endpoint
	})

	if (options?.isDev)
		console.debug('DEBUG', {
			endpoint,
			params,
			content,
			message,
			success
		})

	try {
		if (!success) {
			let msg: string = message ?? 'Erro desconhecido'

			for (const separator of [';', '<br>']) {
				msg = msg.split(separator).join('\n')
			}

			if (options?.isDev) {
				console.error('ERROR', msg)
			}

			const msgError = msg
				.split('\n')
				.filter((item) => !item.includes('FindKey'))
				.join('\n')
				.trim()

			throw new Error(msgError)
		}

		options?.successFunction?.(content)
		return content as T
	} catch (error) {
		if (error instanceof Error) {
			if (options?.errorFunction) {
				options.errorFunction?.(error)
			} else {
				delayedAlert('Atenção', error.message)
			}
		}
	}
}

/**
 * @description Função para fazer requisições para o backend
 * @param endpoint Nome do endpoint
 * @param params Parâmetros da requisição
 * @version 1.0.3
 * @since 1.0.0
 */
export async function serverRequest(
	_endpoint: string,
	params: Params
): Promise<DelphiResponse> {
	let url = _serverIPAddress

	if (!url) {
		return {
			content: {},
			message: 'O endereço do IP do servidor não está configurado.',
			success: false
		}
	}

	if (!(await isOnline()).isConnected) {
		return {
			content: {},
			message: 'O dispositivo não possui acesso à internet',
			success: false
		}
	}

	const body = new FormData()
	for (const key in params) {
		const req = encodedURI(key, params[key])
		body.append(req.name, req.value)
	}

	if (!url.startsWith('https://') && !url.startsWith('http://')) {
		url = 'http://' + url
	}

	const response = await fetch(`${url}/.process`, {
		method: 'POST',
		body: body
	})

	try {
		if (response.headers.get('content-type')?.includes('application/json')) {
			return await response.json()
		}

		return {
			content: response.text(),
			message: 'OK',
			success: true
		}
	} catch (error) {
		let message
		if (error instanceof Error) {
			message = error.message
		} else {
			message = String(error) ?? 'Erro na tentativa de conexão com o backend'
		}

		throw {
			message,
			success: false
		}
	}
}

/**
 * @version 1.0.0
 * @since 1.0.16
 */
function encodedURI(name: string, value: Data) {
	if (typeof value !== 'object') {
		let req = value?.toString() ?? ''
		value = encodeURI(req)
	}

	return { name, value }
}