import {
	getFileService,
	SearchFilesQueryParams,
	SearchScreenRecordingsByAgentQueryParams,
	SearchScreenRecordingsQueryParams,
} from '@webitel/api-services/gen';
import type { SearchFilesByCallParams } from '@webitel/api-services/gen/models';
import { getShallowFieldsToSendFromZodSchema } from '@webitel/api-services/gen/utils';

import { getDefaultGetListResponse, getDefaultGetParams } from '../../defaults';
import {
	applyTransform,
	camelToSnake,
	merge,
	notify,
	sanitize,
	snakeToCamel,
} from '../../transformers';

const getFilesList = async (params: { search?: string }) => {
	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
		SearchFilesQueryParams,
	);

	const {
		page,
		size,
		q,
		sort,
		fields,
		id,
		uploaded_at_from: uploadedAtFrom,
		uploaded_at_to: uploadedAtTo,
		uploadedBy,
		referenceId,
		retentionUntilFrom,
		retentionUntilTo,
	} = applyTransform(params, [
		merge(getDefaultGetParams()),
		sanitize(fieldsToSend),
		camelToSnake(),
	]);

	try {
		const response = await getFileService().searchFiles(
			{
				page,
				size,
				q: q || params.search,
				sort,
				fields,
				id,
				uploadedBy,
				referenceId,
			},
			{
				params: {
					/* grpc-gateway matches nested range filters only by their
					   dotted wire names, which the generated params type flattens */
					'uploaded_at.from': uploadedAtFrom,
					'uploaded_at.to': uploadedAtTo,
					'retention_until.from': retentionUntilFrom,
					'retention_until.to': retentionUntilTo,
				},
			},
		);
		const { items, next } = applyTransform(response.data, [
			merge(getDefaultGetListResponse()),
		]);
		return {
			items,
			next,
		};
	} catch (err) {
		throw applyTransform(err, [
			notify,
		]);
	}
};

const deleteFiles = async (id) => {
	try {
		const response = await getFileService().deleteFiles({
			id,
		});
		return applyTransform(response.data, [
			snakeToCamel(),
		]);
	} catch (err) {
		throw applyTransform(err, [
			notify,
		]);
	}
};

const getScreenRecordingsByUser = async (params: {
	userId: string;
	search?: string;
}) => {
	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
		SearchScreenRecordingsQueryParams,
	);

	const {
		page,
		size,
		q,
		sort,
		fields,
		id,
		uploaded_at_from: uploadedAtFrom,
		uploaded_at_to: uploadedAtTo,
		referenceId,
		retentionUntilFrom,
		retentionUntilTo,
		type,
		channel,
	} = applyTransform(params, [
		merge(getDefaultGetParams()),
		sanitize(fieldsToSend),
		camelToSnake(),
	]);

	try {
		const response = await getFileService().searchScreenRecordings(
			params.userId,
			{
				page,
				size,
				q: q || params.search,
				sort,
				fields: [
					'id',
					...fields,
				],
				id,
				referenceId,
				type,
				channel,
			},
			{
				params: {
					/* grpc-gateway matches nested range filters only by their
					   dotted wire names, which the generated params type flattens */
					'uploaded_at.from': uploadedAtFrom,
					'uploaded_at.to': uploadedAtTo,
					'retention_until.from': retentionUntilFrom,
					'retention_until.to': retentionUntilTo,
				},
			},
		);
		const { items, next } = applyTransform(response.data, [
			merge(getDefaultGetListResponse()),
		]);
		return {
			items,
			next,
		};
	} catch (err) {
		throw applyTransform(err, [
			notify,
		]);
	}
};

const deleteScreenRecordingsByUser = async ({ userId, id }) => {
	try {
		const response = await getFileService().deleteScreenRecordings(
			userId,
			id,
			{},
		);
		return applyTransform(response.data, [
			snakeToCamel(),
		]);
	} catch (err) {
		throw applyTransform(err, [
			notify,
		]);
	}
};

const getScreenRecordingsByAgent = async (params: {
	agentId: string;
	search?: string;
}) => {
	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
		SearchScreenRecordingsByAgentQueryParams,
	);

	const {
		page,
		size,
		q,
		sort,
		fields,
		id,
		uploaded_at_from: uploadedAtFrom,
		uploaded_at_to: uploadedAtTo,
		referenceId,
		retentionUntilFrom,
		retentionUntilTo,
		type,
		channel,
	} = applyTransform(params, [
		merge(getDefaultGetParams()),
		sanitize(fieldsToSend),
		camelToSnake(),
	]);

	try {
		const response = await getFileService().searchScreenRecordingsByAgent(
			params.agentId,
			{
				page,
				size,
				q: q || params.search,
				sort,
				fields: [
					'id',
					'view_name',
					'mime_type',
					...fields,
				],
				id,
				referenceId,
				type,
				channel,
			},
			{
				params: {
					/* grpc-gateway matches nested range filters only by their
					   dotted wire names, which the generated params type flattens */
					'uploaded_at.from': uploadedAtFrom,
					'uploaded_at.to': uploadedAtTo,
					'retention_until.from': retentionUntilFrom,
					'retention_until.to': retentionUntilTo,
				},
			},
		);
		const { items, next } = applyTransform(response.data, [
			merge(getDefaultGetListResponse()),
		]);
		return {
			items,
			next,
		};
	} catch (err) {
		throw applyTransform(err, [
			notify,
		]);
	}
};

const deleteScreenRecordingsByAgent = async ({ agentId, id }) => {
	try {
		const response = await getFileService().deleteScreenRecordingsByAgent(
			agentId,
			id,
			{},
		);
		return applyTransform(response.data, [
			snakeToCamel(),
		]);
	} catch (err) {
		throw applyTransform(err, [
			notify,
		]);
	}
};

const getFilesListByCall = async (
	params: SearchFilesByCallParams & {
		callId: string;
	},
) => {
	const fieldsToSend = getShallowFieldsToSendFromZodSchema(
		SearchFilesQueryParams,
	);

	const requestParams = applyTransform(params, [
		merge(getDefaultGetParams()),
		sanitize(fieldsToSend),
		camelToSnake(),
		(param) => ({
			...param,
			q: param.q ?? param.search,
			'uploaded_at.from': param.uploaded_at_from,
			'uploaded_at.to': param.uploaded_at_to,
		}),
	]);

	try {
		const response = await getFileService().searchFilesByCall(
			params.callId,
			requestParams,
		);

		const { items, next } = applyTransform(response.data, [
			merge(getDefaultGetListResponse()),
		]);

		return {
			items,
			next,
		};
	} catch (err) {
		throw applyTransform(err, [
			notify,
		]);
	}
};

export const FileServicesAPI = {
	getList: getFilesList,
	delete: deleteFiles,
	getScreenRecordingsByUser,
	deleteScreenRecordingsByUser,
	getScreenRecordingsByAgent,
	deleteScreenRecordingsByAgent,
	getListByCall: getFilesListByCall,
};