USDB

Função criada para salvar em memória e facilitar a configuração desabilitar/habilitar campos

     $scope.criarExclusaoMutuaComMemoria = function(config) {
        let processandoExclusao = false;
        let memoriaEstados = {}; // Guarda o estado anterior dos campos
        
        // Função para obter valor aninhado
        function getNestedValue(obj, path) {
            return path.split('.').reduce((current, key) => {
                return current && current[key] !== undefined ? current[key] : null;
            }, obj);
        }
        
        // Função para definir valor aninhado
        function setNestedValue(obj, path, value) {
            const keys = path.split('.');
            const lastKey = keys.pop();
            const target = keys.reduce((current, key) => {
                if (!current[key]) current[key] = {};
                return current[key];
            }, obj);
            target[lastKey] = value;
        }
        
        // Função para detectar o tipo de valor e definir o valor "vazio"
        function getValorVazio(valor) {
            if (typeof valor === 'boolean') return false;
            if (typeof valor === 'number') return 0;
            if (typeof valor === 'string') return '';
            return null;
        }
        
        // 🎯 NOVA FUNÇÃO: Verifica se um campo está ativo considerando valores específicos
        function campoEstaAtivo(path, valorEspecifico = null) {
            const valor = getNestedValue($scope, path);
            
            // Se foi especificado um valor específico, verifica se o campo tem esse valor
            if (valorEspecifico !== null) {
                return valor === valorEspecifico;
            }
            
            // Lógica original para outros tipos
            if (typeof valor === 'boolean') return valor === true;
            if (typeof valor === 'number') return valor !== 0;
            if (typeof valor === 'string') return valor !== '';
            return false;
        }
        
        // 🎯 NOVA FUNÇÃO: Verifica se um campo tem configuração de valor específico
        function temValorEspecifico(campoConfig) {
            return typeof campoConfig === 'object' && campoConfig.campo && campoConfig.valor;
        }
        
        // 🎯 NOVA FUNÇÃO: Extrai o nome do campo de uma configuração
        function getNomeCampo(campoConfig) {
            return temValorEspecifico(campoConfig) ? campoConfig.campo : campoConfig;
        }
        
        // 🎯 NOVA FUNÇÃO: Extrai o valor específico de uma configuração
        function getValorEspecifico(campoConfig) {
            return temValorEspecifico(campoConfig) ? campoConfig.valor : null;
        }
        
        // 🎯 FUNÇÃO: Salva estado atual dos campos na memória
        function salvarEstadoNaMemoria(campoReferencia, camposParaSalvar) {
            if (!memoriaEstados[campoReferencia]) {
                memoriaEstados[campoReferencia] = {};
            }
            
            camposParaSalvar.forEach(campoConfig => {
                const nomeCampo = getNomeCampo(campoConfig);
                const valor = getNestedValue($scope, nomeCampo);
                
                if (campoEstaAtivo(nomeCampo)) {
                    memoriaEstados[campoReferencia][nomeCampo] = valor;
                    console.log(`💾 Salvando estado de '${nomeCampo}':`, valor);
                }
            });
        }
        
        // 🎯 FUNÇÃO: Restaura estado dos campos da memória
        function restaurarEstadoDaMemoria(campoReferencia) {
            if (memoriaEstados[campoReferencia]) {
                console.log(`🔄 Restaurando estados para '${campoReferencia}':`, memoriaEstados[campoReferencia]);
                
                Object.keys(memoriaEstados[campoReferencia]).forEach(campo => {
                    const valorSalvo = memoriaEstados[campoReferencia][campo];
                    setNestedValue($scope, campo, valorSalvo);
                    console.log(`✅ Restaurado '${campo}' para:`, valorSalvo);
                });
                
                // Limpa a memória após restaurar
                delete memoriaEstados[campoReferencia];
            }
        }
        
        // 🎯 FUNÇÃO: Limpa memória de um campo
        function limparMemoriaDoCampo(campoReferencia) {
            if (memoriaEstados[campoReferencia]) {
                console.log(`🗑️ Limpando memória de '${campoReferencia}'`);
                delete memoriaEstados[campoReferencia];
            }
        }
        
        // 🎯 NOVA FUNÇÃO: Limpa um campo considerando configurações especiais
        function limparCampo(campoConfig) {
            const nomeCampo = getNomeCampo(campoConfig);
            
            // Se tem configuração de limpeza específica
            if (temValorEspecifico(campoConfig) && campoConfig.limparPara !== undefined) {
                setNestedValue($scope, nomeCampo, campoConfig.limparPara);
                console.log(`🧹 Limpando '${nomeCampo}' para valor específico:`, campoConfig.limparPara);
            } else {
                // Lógica original
                const valor = getNestedValue($scope, nomeCampo);
                const valorVazio = getValorVazio(valor);
                setNestedValue($scope, nomeCampo, valorVazio);
                console.log(`🧹 Limpando '${nomeCampo}' para valor vazio:`, valorVazio);
            }
        }
        
        // 🎯 NOVA FUNÇÃO: Verifica se dois campos são compatíveis
        function saoCompativeis(campoConfig1, campoConfig2) {
            const nomeCampo1 = getNomeCampo(campoConfig1);
            const nomeCampo2 = getNomeCampo(campoConfig2);
            
            if (config.gruposCompativeis) {
                return config.gruposCompativeis.some(grupo => {
                    const temCampo1 = grupo.some(item => getNomeCampo(item) === nomeCampo1);
                    const temCampo2 = grupo.some(item => getNomeCampo(item) === nomeCampo2);
                    return temCampo1 && temCampo2;
                });
            }
            return false;
        }
        
        // 🎯 NOVA FUNÇÃO: Verifica se é um campo prioritário
        function ehCampoPrioritario(campoConfig) {
            const nomeCampo = getNomeCampo(campoConfig);
            return config.camposPrioritarios && config.camposPrioritarios.some(item => 
                getNomeCampo(item) === nomeCampo
            );
        }
        
        // 🎯 NOVA FUNÇÃO: Obtém campos incompatíveis
        function getCamposIncompativeis(campoReferencia, todosCampos) {
            return todosCampos.filter(campoConfig => {
                const nomeCampo = getNomeCampo(campoConfig);
                const nomeReferencia = getNomeCampo(campoReferencia);
                
                return nomeCampo !== nomeReferencia && !saoCompativeis(campoReferencia, campoConfig);
            });
        }
        
        // 🎯 NOVA FUNÇÃO: Normaliza a lista de campos para incluir apenas nomes únicos para o watchGroup
        function getNomesCamposParaWatch() {
            const nomes = new Set();
            config.campos.forEach(campoConfig => {
                nomes.add(getNomeCampo(campoConfig));
            });
            return Array.from(nomes);
        }
        
        // Cria o $watchGroup automaticamente
        const nomesParaWatch = getNomesCamposParaWatch();
        
        $scope.$watchGroup(nomesParaWatch, function(newValues, oldValues) {
            
            // Evita loop infinito
            if (processandoExclusao) return;
            
            // Evita execução na primeira vez
            if (newValues === oldValues) return;
            
            // Encontra qual campo foi alterado
            let campoAlterado = null;
            let valorAnterior = null;
            let valorAtual = null;
            
            for (let i = 0; i < nomesParaWatch.length; i++) {
                if (newValues[i] !== oldValues[i]) {
                    const nomeCampo = nomesParaWatch[i];
                    valorAnterior = oldValues[i];
                    valorAtual = newValues[i];
                    
                    // Encontra a configuração completa do campo alterado
                    campoAlterado = config.campos.find(campoConfig => 
                        getNomeCampo(campoConfig) === nomeCampo
                    );
                    break;
                }
            }
            
            if (campoAlterado) {
                processandoExclusao = true;
                
                const nomeCampoAlterado = getNomeCampo(campoAlterado);
                const valorEspecifico = getValorEspecifico(campoAlterado);
                
                console.log('Campo alterado:', nomeCampoAlterado, 'de', valorAnterior, 'para', valorAtual);
                if (valorEspecifico) {
                    console.log('Valor específico monitorado:', valorEspecifico);
                }
                
                // Obtém os campos incompatíveis com o campo alterado
                const camposIncompativeis = getCamposIncompativeis(campoAlterado, config.campos);
                
                // 🎯 LÓGICA PRINCIPAL: Se campo foi ATIVADO (considerando valor específico)
                if (campoEstaAtivo(nomeCampoAlterado, valorEspecifico)) {
                    
                    console.log(`✅ Campo '${nomeCampoAlterado}' foi ativado`);
                    
                    // 🎯 Se é um campo prioritário
                    if (ehCampoPrioritario(campoAlterado)) {
                        console.log(`🎯 Campo '${nomeCampoAlterado}' é prioritário - salvando estados`);
                        // Salva o estado dos campos que serão limpos
                        salvarEstadoNaMemoria(nomeCampoAlterado, camposIncompativeis);
                    }
                    
                    // Limpa os campos incompatíveis que estão ativos
                    camposIncompativeis.forEach(campoConfig => {
                        const nomeCampo = getNomeCampo(campoConfig);
                        const valorEspecificoIncompativel = getValorEspecifico(campoConfig);
                        
                        if (campoEstaAtivo(nomeCampo, valorEspecificoIncompativel)) {
                            console.log(`🧹 Limpando campo incompatível: '${nomeCampo}'`);
                            limparCampo(campoConfig);
                        }
                    });
                    
                    // Limpa memória de outros campos prioritários que podem ter conflito
                    if (config.camposPrioritarios) {
                        config.camposPrioritarios.forEach(campoPrioritario => {
                            const nomePrioritario = getNomeCampo(campoPrioritario);
                            if (nomePrioritario !== nomeCampoAlterado) {
                                limparMemoriaDoCampo(nomePrioritario);
                            }
                        });
                    }
                    
                } 
                // 🎯 LÓGICA PRINCIPAL: Se campo foi DESATIVADO
                else {
                    console.log(`❌ Campo '${nomeCampoAlterado}' foi desativado`);
                    
                    // 🎯 Se é um campo prioritário que foi desativado
                    if (ehCampoPrioritario(campoAlterado)) {
                        console.log(`🔄 Campo '${nomeCampoAlterado}' é prioritário - restaurando estados`);
                        // Restaura o estado anterior dos campos
                        restaurarEstadoDaMemoria(nomeCampoAlterado);
                    }
                }
                
                setTimeout(() => {
                    processandoExclusao = false;
                }, 100);
            }
        });
        
        console.log('Exclusão mútua com memória criada para:', config.campos.map(c => getNomeCampo(c)));
        console.log('Grupos compatíveis:', config.gruposCompativeis);
        console.log('Campos prioritários:', config.camposPrioritarios);
    };

Após revisão:

1. Ausência RD selecionada pelo usuário:

• falta bloquear o campo "Nefropatia parenquimatosa RD"
• Quando seleciono "Nefropatia parenquimatosa RE" está desmarcando automaticamente o "Ausência RD" (o certo é o usuário poder utilizar essa opção)
• Nefrectomia total ainda está habilitado = o certo é bloquear as duas opções (lado direito e lado esquerdo)
• As opções de lado direito de "nefrectomia parcial", "rim pélvico", "nódulo sólido", "angiomiolipoma", "cisto complexo", "cálculos não obstrutivos" e "microcálculos calicinais" permanecem passíveis de serem selecionadas (o certo é estarem bloqueadas já que não temos rim direito)
  OBS: no caso dos microcálculos calicinais, tem uma opção "bilaterais" na caixa de seleção que também é bloqueada nesses casos de ausência RD/RE e nefrectomia total RD/RE

2. Ausência RE selecionada pelo usuário:
   Mesma situação do ausência RD, porém do lado esquerdo agora

3. Nefrectomia RD/RE selecionada pelo usuário
   Popover com problema, não consegui testar

4. Rins em Ferradura
   Bloqueou os campos certos, porém está bloqueando os "Cistos Rim Direito" e "Cistos Rim Esquerdo" quando são descritos isoladamente (o certo é não bloquear esses campos). O restante está correto

5. Ectopia Renal Cruzada
   Correto