import { v } from 'convex/values';
import { mutation, query, internalMutation } from './_generated/server';
import { internal } from './_generated/api';
import { Id, Doc } from './_generated/dataModel';

// Validador para períodos
const periodoValidator = v.object({
	dataInicio: v.string(),
	dataFim: v.string(),
	diasCorridos: v.number()
});

// Helper: Calcular dias entre duas datas
function calcularDiasEntreDatas(dataInicio: string, dataFim: string): number {
	const inicio = new Date(dataInicio);
	const fim = new Date(dataFim);
	const diffTime = Math.abs(fim.getTime() - inicio.getTime());
	const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 1;
	return diffDays;
}

// Helper: Agrupar registros de ferias por funcionarioId + anoReferencia
function agruparPorSolicitacao(registros: Array<Doc<'ferias'>>): Array<{
	funcionarioId: Id<'funcionarios'>;
	anoReferencia: number;
	periodos: Array<Doc<'ferias'>>;
	status: string;
	observacao?: string;
	motivoReprovacao?: string;
	gestorId?: Id<'usuarios'>;
	dataAprovacao?: number;
	dataReprovacao?: number;
	historicoAlteracoes?: Array<{
		data: number;
		usuarioId: Id<'usuarios'>;
		acao: string;
	}>;
}> {
	const grupos = new Map<string, Array<Doc<'ferias'>>>();

	for (const registro of registros) {
		const chave = `${registro.funcionarioId}_${registro.anoReferencia}`;
		if (!grupos.has(chave)) {
			grupos.set(chave, []);
		}
		grupos.get(chave)!.push(registro);
	}

	return Array.from(grupos.entries()).map(([_, periodos]) => {
		// Ordenar por data de criação para manter ordem
		periodos.sort((a, b) => a._creationTime - b._creationTime);

		// Pegar informações da primeira solicitação (todos têm os mesmos campos compartilhados)
		const primeiro = periodos[0];

		return {
			funcionarioId: primeiro.funcionarioId,
			anoReferencia: primeiro.anoReferencia,
			periodos,
			status: primeiro.status,
			observacao: primeiro.observacao,
			motivoReprovacao: primeiro.motivoReprovacao,
			gestorId: primeiro.gestorId,
			dataAprovacao: primeiro.dataAprovacao,
			dataReprovacao: primeiro.dataReprovacao,
			historicoAlteracoes: primeiro.historicoAlteracoes
		};
	});
}

// Query: Listar TODAS as solicitações (para RH) - períodos individuais
export const listarTodas = query({
	args: {},
	handler: async (ctx) => {
		const todasFerias = await ctx.db.query('ferias').collect();

		const periodosComDetalhes = await Promise.all(
			todasFerias.map(async (ferias) => {
				const funcionario = await ctx.db.get(ferias.funcionarioId);

				// Buscar usuário do funcionário para obter fotoPerfilUrl
				let fotoPerfilUrl: string | null = null;
				if (funcionario) {
					const usuario = await ctx.db
						.query('usuarios')
						.withIndex('by_funcionarioId', (q) => q.eq('funcionarioId', funcionario._id))
						.first();
					if (usuario?.fotoPerfil) {
						fotoPerfilUrl = await ctx.storage.getUrl(usuario.fotoPerfil);
					}
				}

				// Buscar time do funcionário
				const membroTime = await ctx.db
					.query('timesMembros')
					.withIndex('by_funcionario', (q) => q.eq('funcionarioId', ferias.funcionarioId))
					.filter((q) => q.eq(q.field('ativo'), true))
					.first();

				let time: Doc<'times'> | null = null;
				let gestor: { _id: Id<'usuarios'>; nome: string } | null = null;
				if (membroTime) {
					time = await ctx.db.get(membroTime.timeId);
					// Buscar gestor do time
					if (time?.gestorId) {
						const gestorUsuario = await ctx.db.get(time.gestorId);
						if (gestorUsuario?.funcionarioId) {
							// Buscar funcionário do gestor para obter o nome
							const gestorFuncionario = await ctx.db.get(gestorUsuario.funcionarioId);
							if (gestorFuncionario) {
								gestor = {
									_id: gestorUsuario._id,
									nome: gestorFuncionario.nome
								};
							}
						}
					}
				}

				return {
					...ferias,
					funcionario: funcionario
						? {
								...funcionario,
								fotoPerfilUrl
							}
						: null,
					time,
					gestor
				};
			})
		);

		return periodosComDetalhes.sort((a, b) => b._creationTime - a._creationTime);
	}
});

// Query: Listar solicitações do funcionário - períodos individuais
export const listarMinhasSolicitacoes = query({
	args: {
		funcionarioId: v.id('funcionarios'),
		_refresh: v.optional(v.number()) // Parâmetro para forçar atualização no frontend
	},
	handler: async (ctx, args) => {
		const todasFerias = await ctx.db
			.query('ferias')
			.withIndex('by_funcionario', (q) => q.eq('funcionarioId', args.funcionarioId))
			.collect();

		const funcionario = await ctx.db.get(args.funcionarioId);

		// Buscar time do funcionário
		const membroTime = await ctx.db
			.query('timesMembros')
			.withIndex('by_funcionario', (q) => q.eq('funcionarioId', args.funcionarioId))
			.filter((q) => q.eq(q.field('ativo'), true))
			.first();

		let time = null;
		if (membroTime) {
			time = await ctx.db.get(membroTime.timeId);
		}

		// Retornar períodos individuais com detalhes
		return todasFerias
			.map((ferias) => ({
				...ferias,
				funcionario,
				time
			}))
			.sort((a, b) => b._creationTime - a._creationTime);
	}
});

// Query: Listar solicitações dos subordinados (para gestores) - períodos individuais
export const listarSolicitacoesSubordinados = query({
	args: { gestorId: v.id('usuarios') },
	handler: async (ctx, args) => {
		// Buscar times onde o usuário é gestor
		const timesGestor = await ctx.db
			.query('times')
			.withIndex('by_gestor', (q) => q.eq('gestorId', args.gestorId))
			.filter((q) => q.eq(q.field('ativo'), true))
			.collect();

		const todasFerias: Array<Doc<'ferias'>> = [];

		for (const time of timesGestor) {
			// Buscar membros do time
			const membros = await ctx.db
				.query('timesMembros')
				.withIndex('by_time_and_ativo', (q) => q.eq('timeId', time._id).eq('ativo', true))
				.collect();

			// Buscar férias de cada membro
			for (const membro of membros) {
				const ferias = await ctx.db
					.query('ferias')
					.withIndex('by_funcionario', (q) => q.eq('funcionarioId', membro.funcionarioId))
					.collect();

				todasFerias.push(...ferias);
			}
		}

		// Adicionar info do funcionário e time para cada período
		const periodosComDetalhes = await Promise.all(
			todasFerias.map(async (ferias) => {
				const funcionario = await ctx.db.get(ferias.funcionarioId);

				// Buscar usuário do funcionário para obter fotoPerfilUrl
				let fotoPerfilUrl: string | null = null;
				if (funcionario) {
					const usuario = await ctx.db
						.query('usuarios')
						.withIndex('by_funcionarioId', (q) => q.eq('funcionarioId', funcionario._id))
						.first();
					if (usuario?.fotoPerfil) {
						fotoPerfilUrl = await ctx.storage.getUrl(usuario.fotoPerfil);
					}
				}

				// Buscar time do funcionário
				const membroTime = await ctx.db
					.query('timesMembros')
					.withIndex('by_funcionario', (q) => q.eq('funcionarioId', ferias.funcionarioId))
					.filter((q) => q.eq(q.field('ativo'), true))
					.first();

				let time = null;
				if (membroTime) {
					time = await ctx.db.get(membroTime.timeId);
				}

				return {
					...ferias,
					funcionario: funcionario
						? {
								...funcionario,
								fotoPerfilUrl
							}
						: null,
					time
				};
			})
		);

		return periodosComDetalhes.sort((a, b) => b._creationTime - a._creationTime);
	}
});

// Query: Obter detalhes de um período individual
export const obterDetalhes = query({
	args: {
		feriasId: v.id('ferias')
	},
	handler: async (ctx, args) => {
		const ferias = await ctx.db.get(args.feriasId);

		if (!ferias) return null;

		const funcionario = await ctx.db.get(ferias.funcionarioId);

		// Buscar usuário do funcionário para obter fotoPerfilUrl
		let fotoPerfilUrl: string | null = null;
		if (funcionario) {
			const usuario = await ctx.db
				.query('usuarios')
				.withIndex('by_funcionarioId', (q) => q.eq('funcionarioId', funcionario._id))
				.first();
			if (usuario?.fotoPerfil) {
				fotoPerfilUrl = await ctx.storage.getUrl(usuario.fotoPerfil);
			}
		}

		let gestor = null;
		if (ferias.gestorId) {
			gestor = await ctx.db.get(ferias.gestorId);
		}

		// Buscar time do funcionário
		const membroTime = await ctx.db
			.query('timesMembros')
			.withIndex('by_funcionario', (q) => q.eq('funcionarioId', ferias.funcionarioId))
			.filter((q) => q.eq(q.field('ativo'), true))
			.first();

		let time = null;
		if (membroTime) {
			time = await ctx.db.get(membroTime.timeId);
		}

		return {
			...ferias,
			funcionario: funcionario
				? {
						...funcionario,
						fotoPerfilUrl
					}
				: null,
			gestor,
			time
		};
	}
});

// Mutation: Criar solicitação de férias (cria um registro por período)
export const criarSolicitacao = mutation({
	args: {
		funcionarioId: v.id('funcionarios'),
		anoReferencia: v.number(),
		periodos: v.array(periodoValidator),
		observacao: v.optional(v.string())
	},
	returns: v.array(v.id('ferias')),
	handler: async (ctx, args) => {
		if (args.periodos.length === 0) {
			throw new Error('É necessário adicionar pelo menos 1 período');
		}

		const funcionario = await ctx.db.get(args.funcionarioId);
		if (!funcionario) throw new Error('Funcionário não encontrado');

		// Buscar usuário que está criando (pode não ser o próprio funcionário)
		const usuario = await ctx.db
			.query('usuarios')
			.withIndex('by_funcionarioId', (q) => q.eq('funcionarioId', args.funcionarioId))
			.first();

		const historicoInicial = [
			{
				data: Date.now(),
				usuarioId: usuario?._id || funcionario.gestorId!,
				acao: 'Solicitação criada'
			}
		];

		// Criar um registro para cada período
		const idsCriados: Array<Id<'ferias'>> = [];
		for (const periodo of args.periodos) {
			const feriasId = await ctx.db.insert('ferias', {
				funcionarioId: args.funcionarioId,
				anoReferencia: args.anoReferencia,
				dataInicio: periodo.dataInicio,
				dataFim: periodo.dataFim,
				diasFerias: periodo.diasCorridos,
				status: 'aguardando_aprovacao',
				observacao: args.observacao,
				diasAbono: 0,
				historicoAlteracoes: historicoInicial
			});
			idsCriados.push(feriasId);
		}

		// Notificar gestor (usar o primeiro ID criado)
		if (funcionario.gestorId && idsCriados.length > 0) {
			await ctx.db.insert('notificacoesFerias', {
				destinatarioId: funcionario.gestorId,
				feriasId: idsCriados[0],
				tipo: 'nova_solicitacao',
				lida: false,
				mensagem: `${funcionario.nome} solicitou férias`
			});
		}

		return idsCriados;
	}
});

// Mutation: Aprovar período de férias individual
export const aprovar = mutation({
	args: {
		feriasId: v.id('ferias'),
		gestorId: v.id('usuarios')
	},
	returns: v.null(),
	handler: async (ctx, args) => {
		// Buscar o registro específico
		const registro = await ctx.db.get(args.feriasId);

		if (!registro) {
			throw new Error('Período de férias não encontrado');
		}

		// Verificar se está aguardando aprovação
		if (registro.status !== 'aguardando_aprovacao') {
			throw new Error('Este período já foi processado');
		}

		const funcionario = await ctx.db.get(registro.funcionarioId);

		// Atualizar o registro
		await ctx.db.patch(registro._id, {
			status: 'aprovado',
			gestorId: args.gestorId,
			dataAprovacao: Date.now(),
			historicoAlteracoes: [
				...(registro.historicoAlteracoes || []),
				{
					data: Date.now(),
					usuarioId: args.gestorId,
					acao: 'Aprovado'
				}
			]
		});

		// Notificar funcionário
		if (funcionario) {
			const usuario = await ctx.db
				.query('usuarios')
				.withIndex('by_funcionarioId', (q) => q.eq('funcionarioId', funcionario._id))
				.first();

			if (usuario) {
				await ctx.db.insert('notificacoesFerias', {
					destinatarioId: usuario._id,
					feriasId: registro._id,
					tipo: 'aprovado',
					lida: false,
					mensagem: `Período de férias de ${registro.diasFerias} dias foi aprovado!`
				});
			}
		}

		return null;
	}
});

// Mutation: Reprovar período de férias individual
export const reprovar = mutation({
	args: {
		feriasId: v.id('ferias'),
		gestorId: v.id('usuarios'),
		motivoReprovacao: v.string()
	},
	returns: v.null(),
	handler: async (ctx, args) => {
		// Buscar o registro específico
		const registro = await ctx.db.get(args.feriasId);

		if (!registro) {
			throw new Error('Período de férias não encontrado');
		}

		// Verificar se está aguardando aprovação
		if (registro.status !== 'aguardando_aprovacao') {
			throw new Error('Este período já foi processado');
		}

		const funcionario = await ctx.db.get(registro.funcionarioId);

		// Atualizar o registro
		await ctx.db.patch(registro._id, {
			status: 'reprovado',
			gestorId: args.gestorId,
			dataReprovacao: Date.now(),
			motivoReprovacao: args.motivoReprovacao,
			historicoAlteracoes: [
				...(registro.historicoAlteracoes || []),
				{
					data: Date.now(),
					usuarioId: args.gestorId,
					acao: `Reprovado: ${args.motivoReprovacao}`
				}
			]
		});

		// Notificar funcionário
		if (funcionario) {
			const usuario = await ctx.db
				.query('usuarios')
				.withIndex('by_funcionarioId', (q) => q.eq('funcionarioId', funcionario._id))
				.first();

			if (usuario) {
				await ctx.db.insert('notificacoesFerias', {
					destinatarioId: usuario._id,
					feriasId: registro._id,
					tipo: 'reprovado',
					lida: false,
					mensagem: `Período de férias de ${registro.diasFerias} dias foi reprovado: ${args.motivoReprovacao}`
				});
			}
		}

		return null;
	}
});

// Mutation: Ajustar data e aprovar período individual
export const ajustarEAprovar = mutation({
	args: {
		feriasId: v.id('ferias'),
		gestorId: v.id('usuarios'),
		novaDataInicio: v.string(),
		novaDataFim: v.string()
	},
	returns: v.null(),
	handler: async (ctx, args) => {
		// Buscar o registro específico
		const registroAntigo = await ctx.db.get(args.feriasId);

		if (!registroAntigo) {
			throw new Error('Período de férias não encontrado');
		}

		// Verificar se está aguardando aprovação
		if (registroAntigo.status !== 'aguardando_aprovacao') {
			throw new Error('Este período já foi processado');
		}

		const funcionario = await ctx.db.get(registroAntigo.funcionarioId);

		// Calcular novos dias
		const novosDias = calcularDiasEntreDatas(args.novaDataInicio, args.novaDataFim);

		// Atualizar o registro com novas datas
		await ctx.db.patch(registroAntigo._id, {
			dataInicio: args.novaDataInicio,
			dataFim: args.novaDataFim,
			diasFerias: novosDias,
			status: 'data_ajustada_aprovada',
			gestorId: args.gestorId,
			dataAprovacao: Date.now(),
			historicoAlteracoes: [
				...(registroAntigo.historicoAlteracoes || []),
				{
					data: Date.now(),
					usuarioId: args.gestorId,
					acao: `Data ajustada e aprovada: ${registroAntigo.dataInicio} - ${registroAntigo.dataFim} → ${args.novaDataInicio} - ${args.novaDataFim}`
				}
			]
		});

		// Notificar funcionário
		if (funcionario) {
			const usuario = await ctx.db
				.query('usuarios')
				.withIndex('by_funcionarioId', (q) => q.eq('funcionarioId', funcionario._id))
				.first();

			if (usuario) {
				await ctx.db.insert('notificacoesFerias', {
					destinatarioId: usuario._id,
					feriasId: registroAntigo._id,
					tipo: 'data_ajustada',
					lida: false,
					mensagem: `Período de férias foi aprovado com ajuste de datas: ${args.novaDataInicio} a ${args.novaDataFim}`
				});
			}
		}

		return null;
	}
});

// Query: Verificar status de férias automático
export const verificarStatusFerias = query({
	args: { funcionarioId: v.id('funcionarios') },
	returns: v.union(v.literal('ativo'), v.literal('em_ferias')),
	handler: async (ctx, args) => {
		const hoje = new Date();
		hoje.setHours(0, 0, 0, 0);

		const feriasAprovadas = await ctx.db
			.query('ferias')
			.withIndex('by_funcionario_and_status', (q) =>
				q.eq('funcionarioId', args.funcionarioId).eq('status', 'aprovado')
			)
			.collect();

		const feriasAjustadas = await ctx.db
			.query('ferias')
			.withIndex('by_funcionario_and_status', (q) =>
				q.eq('funcionarioId', args.funcionarioId).eq('status', 'data_ajustada_aprovada')
			)
			.collect();

		const feriasEmFerias = await ctx.db
			.query('ferias')
			.withIndex('by_funcionario_and_status', (q) =>
				q.eq('funcionarioId', args.funcionarioId).eq('status', 'EmFérias')
			)
			.collect();

		const todasFerias = [...feriasAprovadas, ...feriasAjustadas, ...feriasEmFerias];

		for (const ferias of todasFerias) {
			const inicio = new Date(ferias.dataInicio);
			const fim = new Date(ferias.dataFim);
			inicio.setHours(0, 0, 0, 0);
			fim.setHours(23, 59, 59, 999);

			if (hoje >= inicio && hoje <= fim) {
				return 'em_ferias';
			}
		}

		return 'ativo';
	}
});

// Query: Obter notificações não lidas
export const obterNotificacoesNaoLidas = query({
	args: { usuarioId: v.id('usuarios') },
	handler: async (ctx, args) => {
		return await ctx.db
			.query('notificacoesFerias')
			.withIndex('by_destinatario_and_lida', (q) =>
				q.eq('destinatarioId', args.usuarioId).eq('lida', false)
			)
			.collect();
	}
});

// Mutation: Marcar notificação como lida
export const marcarComoLida = mutation({
	args: { notificacaoId: v.id('notificacoesFerias') },
	returns: v.null(),
	handler: async (ctx, args) => {
		await ctx.db.patch(args.notificacaoId, { lida: true });
		return null;
	}
});

// Mutation: Atualizar status de um período individual
export const atualizarStatus = mutation({
	args: {
		feriasId: v.id('ferias'),
		novoStatus: v.union(
			v.literal('aguardando_aprovacao'),
			v.literal('aprovado'),
			v.literal('reprovado'),
			v.literal('data_ajustada_aprovada'),
			v.literal('Cancelado_RH')
		),
		usuarioId: v.id('usuarios')
	},
	returns: v.null(),
	handler: async (ctx, args) => {
		// Buscar o registro específico
		const registro = await ctx.db.get(args.feriasId);

		if (!registro) {
			throw new Error('Período de férias não encontrado');
		}

		// Atualizar status e histórico
		const acao = `Status alterado para ${args.novoStatus}`;

		const updateData: {
			status: typeof args.novoStatus;
			historicoAlteracoes: Array<{
				data: number;
				usuarioId: Id<'usuarios'>;
				acao: string;
			}>;
			gestorId?: undefined;
			dataAprovacao?: undefined;
			dataReprovacao?: undefined;
			motivoReprovacao?: undefined;
		} = {
			status: args.novoStatus,
			historicoAlteracoes: [
				...(registro.historicoAlteracoes || []),
				{
					data: Date.now(),
					usuarioId: args.usuarioId,
					acao
				}
			]
		};

		// Se voltar para aguardando_aprovacao, limpar campos relacionados
		if (args.novoStatus === 'aguardando_aprovacao') {
			await ctx.db.patch(registro._id, {
				...updateData,
				gestorId: undefined,
				dataAprovacao: undefined,
				dataReprovacao: undefined,
				motivoReprovacao: undefined
			});
		} else {
			await ctx.db.patch(registro._id, updateData);
		}

		return null;
	}
});

// Internal Mutation: Atualizar status de todos os funcionários
export const atualizarStatusTodosFuncionarios = internalMutation({
	args: {},
	returns: v.null(),
	handler: async (ctx) => {
		const funcionarios = await ctx.db.query('funcionarios').collect();

		for (const func of funcionarios) {
			const hoje = new Date();
			hoje.setHours(0, 0, 0, 0);

			// Buscar todos os registros de férias que podem estar em férias
			// Buscar por status específico para criar mapas de referência
			const feriasAprovadas = await ctx.db
				.query('ferias')
				.withIndex('by_funcionario_and_status', (q) =>
					q.eq('funcionarioId', func._id).eq('status', 'aprovado')
				)
				.collect();

			const feriasAjustadas = await ctx.db
				.query('ferias')
				.withIndex('by_funcionario_and_status', (q) =>
					q.eq('funcionarioId', func._id).eq('status', 'data_ajustada_aprovada')
				)
				.collect();

			const feriasEmFerias = await ctx.db
				.query('ferias')
				.withIndex('by_funcionario_and_status', (q) =>
					q.eq('funcionarioId', func._id).eq('status', 'EmFérias')
				)
				.collect();

			// Criar mapas para verificar status original
			// Quando um registro está "EmFérias", precisamos saber qual era o status anterior
			// Vamos usar o histórico ou verificar se o ID estava nas listas antes
			const idsAprovados = new Set(feriasAprovadas.map((f) => f._id));
			const idsAjustados = new Set(feriasAjustadas.map((f) => f._id));

			// Para registros que estão "EmFérias", verificar o histórico para determinar status anterior
			// Se não houver histórico claro, usar lógica: se foi aprovado recentemente, provavelmente era "aprovado"
			// Por enquanto, vamos usar uma heurística: se o registro está "EmFérias" e não está nas listas,
			// vamos verificar o histórico de alterações para encontrar o status anterior
			const statusAnteriorPorId = new Map<Id<'ferias'>, 'aprovado' | 'data_ajustada_aprovada'>();

			for (const ferias of feriasEmFerias) {
				// Verificar histórico para encontrar status anterior
				if (ferias.historicoAlteracoes && ferias.historicoAlteracoes.length > 0) {
					// Procurar pela última alteração que mudou para "EmFérias" ou antes disso
					const historico = ferias.historicoAlteracoes;
					for (let i = historico.length - 1; i >= 0; i--) {
						const entrada = historico[i];
						if (entrada.acao.includes('Aprovado') || entrada.acao.includes('aprovado')) {
							statusAnteriorPorId.set(ferias._id, 'aprovado');
							break;
						} else if (
							entrada.acao.includes('Data ajustada') ||
							entrada.acao.includes('ajustada')
						) {
							statusAnteriorPorId.set(ferias._id, 'data_ajustada_aprovada');
							break;
						}
					}
				}
				// Se não encontrou no histórico, usar fallback: assumir "aprovado"
				if (!statusAnteriorPorId.has(ferias._id)) {
					statusAnteriorPorId.set(ferias._id, 'aprovado');
				}
			}

			// Combinar todos os registros
			const todasFerias = [...feriasAprovadas, ...feriasAjustadas, ...feriasEmFerias];

			let emFerias = false;
			for (const ferias of todasFerias) {
				const inicio = new Date(ferias.dataInicio);
				const fim = new Date(ferias.dataFim);
				inicio.setHours(0, 0, 0, 0);
				fim.setHours(23, 59, 59, 999);

				if (hoje >= inicio && hoje <= fim) {
					emFerias = true;

					// Atualizar status para "EmFérias" se ainda não estiver
					if (ferias.status !== 'EmFérias') {
						await ctx.db.patch(ferias._id, {
							status: 'EmFérias'
						});
					}
				} else {
					// Se saiu do período e está "EmFérias", voltar para o status anterior
					if (ferias.status === 'EmFérias') {
						// Determinar status anterior
						let statusAnterior: 'aprovado' | 'data_ajustada_aprovada';

						if (idsAprovados.has(ferias._id)) {
							statusAnterior = 'aprovado';
						} else if (idsAjustados.has(ferias._id)) {
							statusAnterior = 'data_ajustada_aprovada';
						} else {
							// Usar histórico ou fallback
							statusAnterior = statusAnteriorPorId.get(ferias._id) || 'aprovado';
						}

						await ctx.db.patch(ferias._id, {
							status: statusAnterior
						});
					}
				}
			}

			const novoStatus = emFerias ? 'em_ferias' : 'ativo';

			if (func.statusFerias !== novoStatus) {
				await ctx.db.patch(func._id, { statusFerias: novoStatus });
			}
		}

		return null;
	}
});
