import { HttpErrorResponse } from '@angular/common/http';
import { apiCodes } from '@i18n/api-codes';
import { lastValueFrom, MonoTypeOperatorFunction, Observable, pipe } from 'rxjs';
import { map, tap } from 'rxjs/operators';
import { HttpPlainResponse } from '../models/response.interface';

export const isValidResponse = (status: number) => status >= 200 && status < 300;

const validateResponse = <T extends HttpPlainResponse>(response: T) => {
	const { status, code, message } = response;
	if (!isValidResponse(status)) {
		throw new Error(apiCodes[code]?.msg ?? message);
	}
	return response;
};

export const handleRequest = async <T extends HttpPlainResponse>(
	request: Observable<T>
): Promise<T> => {
	try {
		const response = await lastValueFrom(request);
		return validateResponse(response);
	} catch (error) {
		if (error instanceof HttpErrorResponse) {
			const errorBody = error.error as Partial<
				HttpPlainResponse & { data?: { plus_ones_available?: unknown } }
			>;
			if (errorBody && typeof errorBody.code === 'number' && typeof errorBody.status === 'number') {
				const codeKey = String(errorBody.code);
				const baseApiMessage = apiCodes[codeKey]?.msg;

				if (codeKey === '1253') {
					let message =
						baseApiMessage ||
						'No hay tantos lugares disponibles adicionales, actualmente tenemos sólo'; // Default message for 1253

					const dataPayload = errorBody.data;
					if (
						dataPayload &&
						typeof dataPayload === 'object' &&
						dataPayload !== null &&
						'plus_ones_available' in dataPayload &&
						typeof dataPayload.plus_ones_available === 'number'
					) {
						message += ` ${dataPayload.plus_ones_available}`;
					}
					throw new Error(message);
				} else {
					// Original logic for other codes
					const detailMessage = errorBody.message || error.message;
					throw new Error(baseApiMessage ?? detailMessage);
				}
			} else {
				throw new Error(error.message || 'Se produjo un error en la solicitud.');
			}
		}
		throw error;
	}
};

export const validateMutation = <T extends HttpPlainResponse>(
	callback: () => void = () => {}
): MonoTypeOperatorFunction<T> =>
	pipe(
		map((response) => validateResponse(response)),
		tap(callback)
	);