package br.gov.sigefp.api.integration;

import br.gov.sigefp.admin.repository.UserAccountRepository;
import br.gov.sigefp.org.repository.MinistryRepository;
import br.gov.sigefp.org.repository.OrgUnitRepository;
import br.gov.sigefp.org.repository.PositionRepository;
import br.gov.sigefp.rh.repository.AgentRepository;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.UUID;

/**
 * Serviço para validações cruzadas entre módulos.
 * Valida se IDs referenciados existem nos módulos correspondentes.
 */
@Service
@RequiredArgsConstructor
@Slf4j
public class CrossModuleValidationService {

    private final MinistryRepository ministryRepository;
    private final OrgUnitRepository orgUnitRepository;
    private final PositionRepository positionRepository;
    private final AgentRepository agentRepository;
    private final UserAccountRepository userAccountRepository;

    /**
     * Valida se um ministério existe.
     */
    @Transactional(readOnly = true)
    public boolean validateMinistry(UUID ministryId) {
        if (ministryId == null) {
            return false;
        }
        boolean exists = ministryRepository.existsById(ministryId);
        if (!exists) {
            log.warn("Ministério não encontrado: {}", ministryId);
        }
        return exists;
    }

    /**
     * Valida se uma unidade organizacional existe.
     */
    @Transactional(readOnly = true)
    public boolean validateOrgUnit(UUID orgUnitId) {
        if (orgUnitId == null) {
            return false;
        }
        boolean exists = orgUnitRepository.existsById(orgUnitId);
        if (!exists) {
            log.warn("Unidade organizacional não encontrada: {}", orgUnitId);
        }
        return exists;
    }

    /**
     * Valida se uma posição existe.
     */
    @Transactional(readOnly = true)
    public boolean validatePosition(UUID positionId) {
        if (positionId == null) {
            return false;
        }
        boolean exists = positionRepository.existsById(positionId);
        if (!exists) {
            log.warn("Posição não encontrada: {}", positionId);
        }
        return exists;
    }

    /**
     * Valida se um agente existe.
     */
    @Transactional(readOnly = true)
    public boolean validateAgent(UUID agentId) {
        if (agentId == null) {
            return false;
        }
        boolean exists = agentRepository.existsById(agentId);
        if (!exists) {
            log.warn("Agente não encontrado: {}", agentId);
        }
        return exists;
    }

    /**
     * Valida se um usuário existe.
     */
    @Transactional(readOnly = true)
    public boolean validateUser(UUID userId) {
        if (userId == null) {
            return false;
        }
        boolean exists = userAccountRepository.existsById(userId);
        if (!exists) {
            log.warn("Usuário não encontrado: {}", userId);
        }
        return exists;
    }

    /**
     * Valida se uma unidade organizacional pertence ao mesmo ministério.
     */
    @Transactional(readOnly = true)
    public boolean validateOrgUnitBelongsToMinistry(UUID orgUnitId, UUID ministryId) {
        if (orgUnitId == null || ministryId == null) {
            return false;
        }
        return orgUnitRepository.findById(orgUnitId)
                .map(orgUnit -> ministryId.equals(orgUnit.getMinistry().getId()))
                .orElse(false);
    }
}
