plugin.py

# -*- coding: utf-8 -*-
"""
NPN Explorer Colombia - Lógica Principal e Integración en QGIS.
"""

import os
from PyQt5.QtWidgets import QMessageBox, QAction, QApplication
from PyQt5.QtGui import QIcon, QCursor
from PyQt5.QtCore import Qt, QVariant

from qgis.core import (QgsProject, QgsFeatureRequest, 
                       QgsGeometry, QgsField, edit, QgsMessageLog, QgsDistanceArea,
                       QgsCoordinateTransform, QgsCoordinateReferenceSystem)

# Compatibilidad de tipos de capa para QGIS 3.30+ y QGIS 4.x
try:
    from qgis.core import Qgis
    _VECTOR_LAYER_TYPE = Qgis.LayerType.Vector
except (ImportError, AttributeError):
    try:
        from qgis.core import QgsMapLayerType
        _VECTOR_LAYER_TYPE = QgsMapLayerType.VectorLayer
    except ImportError:
        _VECTOR_LAYER_TYPE = 0  # Fallback estándar (QgsMapLayerType.VectorLayer era 0)
from qgis.gui import QgsMapToolEmitPoint, QgsMapTool

from .ui import NPNExplorerDockWidget
from .parser import parse_npn, clean_npn
from .vur_client import VurClient
from .colombia_en_mapas_client import ColombiaEnMapasClient
from .logger import log_debug, log_info, log_warning, log_error

class NPNMapIdentifyTool(QgsMapTool):
    """Herramienta de mapa para identificar predios al hacer clic."""
    
    def __init__(self, canvas, plugin):
        super(NPNMapIdentifyTool, self).__init__(canvas)
        self.canvas = canvas
        self.plugin = plugin
        self.setCursor(Qt.CrossCursor)

    def canvasReleaseEvent(self, event):
        """Captura el evento del clic izquierdo del mouse en el mapa."""
        if event.button() == Qt.LeftButton:
            point = self.toMapCoordinates(event.pos())
            self.plugin.identify_predio_at_point(point)


class NPNDecoder:
    """Clase principal del plugin que interactúa con el entorno de QGIS."""

    def __init__(self, iface):
        self.iface = iface
        self.canvas = iface.mapCanvas()
        
        # Referencias a la UI y herramientas
        self.dock = None
        self.map_tool = None
        self.prev_map_tool = None
        
        # Clientes de Integración Externa
        self.vur_client = VurClient()
        self.colombia_en_mapas_client = ColombiaEnMapasClient()
        
        # Acciones QGIS
        self.action_show = None
        
        log_info("Plugin NPN Decoder instanciado y listo.")

    def initGui(self):
        """Inicializa las barras de herramientas y menús en la interfaz de QGIS."""
        log_info("Inicializando la interfaz de usuario (GUI) del plugin...")
        plugin_dir = os.path.dirname(__file__)
        icon_path = os.path.join(plugin_dir, "icon.png")
        
        if os.path.exists(icon_path):
            icon = QIcon(icon_path)
        else:
            icon = QIcon()
            
        self.action_show = QAction(
            icon,
            "NPN Decoder",
            self.iface.mainWindow()
        )
        self.action_show.setStatusTip("Analiza, desglosa y compara NPNs catastrales con la Ventanilla SNR VUR.")
        self.action_show.triggered.connect(self.run)

        # Añadir al menú Vectorial y Barra de Herramientas
        self.iface.addVectorToolBarIcon(self.action_show)
        self.iface.addPluginToVectorMenu("NPN Decoder", self.action_show)

        # Crear y configurar el DockWidget
        self.dock = NPNExplorerDockWidget(self.iface.mainWindow())
        self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock)
        self.dock.hide()

        # Conectar señales de la UI
        self.dock.map_tool_toggled.connect(self.handle_map_tool_toggle)
        self.dock.npn_manual_submitted.connect(self.decode_manual_npn)
        self.dock.batch_validation_requested.connect(self.run_batch_validation)
        self.dock.batch_qc_add_fields_requested.connect(self.add_qc_fields_to_layer)
        
        # Conectar señales VUR
        self.dock.vur_login_requested.connect(self.execute_vur_login)

        # Escuchar eventos de QgsProject para mantener combos actualizados
        QgsProject.instance().layersAdded.connect(self.refresh_layers_combo)
        QgsProject.instance().layersRemoved.connect(self.refresh_layers_combo)
        self.dock.combo_layers.currentIndexChanged.connect(self.refresh_fields_combo)

        # Inicializar herramienta de mapa
        self.map_tool = NPNMapIdentifyTool(self.canvas, self)
        log_info("Interfaz de usuario del plugin cargada e inicializada correctamente.")

    def unload(self):
        """Elimina el plugin de la interfaz de QGIS."""
        log_info("Descargando el plugin NPN Decoder y liberando recursos...")
        self.iface.removeVectorToolBarIcon(self.action_show)
        self.iface.removePluginVectorMenu("NPN Decoder", self.action_show)

        if self.canvas.mapTool() == self.map_tool:
            self.canvas.unsetMapTool(self.map_tool)

        if self.dock:
            self.dock.close()
            self.dock.deleteLater()
        log_info("Plugin descargado con éxito de QGIS.")

    def run(self):
        """Acción principal al hacer clic sobre el botón del plugin."""
        log_info("Ejecutando acción principal: mostrando el DockWidget de NPN Decoder...")
        self.dock.show()
        self.refresh_layers_combo()
        self.refresh_fields_combo()

    # --- Gestión de Sesión VUR ---

    def execute_vur_login(self, username, password, cookie, is_demo):
        """Realiza la autenticación ante la Ventanilla Única de Registro."""
        log_info(f"Petición de inicio de sesión en VUR solicitada por la interfaz | Tiene Cookie: {bool(cookie)} | Modo Demo: {is_demo}")
        # Mostrar cursor de espera
        QApplication.setOverrideCursor(Qt.WaitCursor)
        try:
            success, message = self.vur_client.login(username, password, force_live=not is_demo, session_cookie=cookie)
            log_info(f"Resultado del inicio de sesión en VUR: {'Éxito' if success else 'Fallo'} - {message}")
            self.dock.update_vur_login_status(success, message)
        except Exception as e:
            log_error(f"Error inesperado al intentar iniciar sesión en VUR: {str(e)}", exc_info=True)
            self.dock.update_vur_login_status(False, f"Error inesperado: {str(e)}")
        finally:
            QApplication.restoreOverrideCursor()

    # --- Sincronización de Capas y Campos ---

    def refresh_layers_combo(self):
        if not self.dock:
            return
        self.dock.combo_layers.blockSignals(True)
        current_selection = self.dock.combo_layers.currentText()
        vector_layers = []
        for layer in QgsProject.instance().mapLayers().values():
            if layer.type() == _VECTOR_LAYER_TYPE:
                vector_layers.append(layer.name())
        vector_layers.sort()
        active_layer = self.iface.activeLayer()
        active_name = active_layer.name() if active_layer else None
        self.dock.set_layers(vector_layers, active_name or current_selection)
        self.dock.combo_layers.blockSignals(False)
        self.refresh_fields_combo()

    def refresh_fields_combo(self):
        if not self.dock:
            return
        layer_name = self.dock.get_selected_layer()
        if not layer_name:
            self.dock.combo_fields.clear()
            return
        layer = None
        for lyr in QgsProject.instance().mapLayers().values():
            if lyr.name() == layer_name and lyr.type() == _VECTOR_LAYER_TYPE:
                layer = lyr
                break
        if layer:
            fields = [field.name() for field in layer.fields()]
            self.dock.set_fields(fields)
        else:
            self.dock.combo_fields.clear()

    # --- Herramienta de Selección en Mapa e Identificación ---

    def handle_map_tool_toggle(self, active):
        log_info(f"Estado de la herramienta de mapa toggleado: {active}")
        if active:
            self.prev_map_tool = self.canvas.mapTool()
            self.canvas.setMapTool(self.map_tool)
        else:
            if self.canvas.mapTool() == self.map_tool:
                if self.prev_map_tool:
                    self.canvas.setMapTool(self.prev_map_tool)
                else:
                    self.canvas.unsetMapTool(self.map_tool)

    def calculate_feature_area_and_centroid(self, feature, layer):
        """Calcula el área en metros cuadrados y el centroide WGS84 de una entidad de forma ultra-robusta usando el origen nacional Magna-Sirgas EPSG:9377 de Colombia."""
        area_qgis = None
        lat_qgis = None
        lon_qgis = None
        
        try:
            geom = feature.geometry()
            if not geom or geom.isEmpty():
                return None, None, None
                
            # 1. Área: Reproyectamos al Origen Nacional de Colombia (EPSG:9377) para máxima exactitud en m2
            target_crs = QgsCoordinateReferenceSystem("EPSG:9377")
            if layer.crs() != target_crs:
                transform_area = QgsCoordinateTransform(layer.crs(), target_crs, QgsProject.instance())
                geom_projected = QgsGeometry(geom)
                geom_projected.transform(transform_area)
                area_qgis = geom_projected.area()
            else:
                area_qgis = geom.area()
            log_info(f"Área catastral calculada con reproyección oficial EPSG:9377: {area_qgis:.2f} m²")
        except Exception as e:
            log_warning(f"Error al calcular área con EPSG:9377: {str(e)}. Usando QgsDistanceArea fallback.")
            try:
                da = QgsDistanceArea()
                da.setSourceCrs(layer.crs(), QgsProject.instance().transformContext())
                da.setEllipsoid("WGS84")
                area_qgis = da.measureArea(feature.geometry())
            except Exception as ex:
                log_error(f"Fallo crítico en el cálculo de área fallback: {str(ex)}")
                
        try:
            # 2. Centroide: Reproyectamos a EPSG:4326 (WGS84)
            centroid_geom = feature.geometry().centroid()
            if centroid_geom and not centroid_geom.isEmpty():
                centroid_point = centroid_geom.asPoint()
                wgs84_crs = QgsCoordinateReferenceSystem("EPSG:4326")
                if layer.crs() != wgs84_crs:
                    transform_to_wgs84 = QgsCoordinateTransform(layer.crs(), wgs84_crs, QgsProject.instance())
                    point_wgs84 = transform_to_wgs84.transform(centroid_point)
                    lat_qgis = point_wgs84.y()
                    lon_qgis = point_wgs84.x()
                else:
                    lat_qgis = centroid_point.y()
                    lon_qgis = centroid_point.x()
        except Exception as e:
            log_error(f"Error al calcular centroide de la entidad: {str(e)}")
            
        return area_qgis, lat_qgis, lon_qgis

    def identify_predio_at_point(self, point):
        """Identifica el predio en mapa y realiza la consulta en paralelo de Catastro y VUR."""
        layer_name = self.dock.get_selected_layer()
        field_name = self.dock.get_selected_field()
        
        log_info(f"Clic en mapa detectado en coordenadas: ({point.x():.6f}, {point.y():.6f})")
        log_info(f"Capa de búsqueda activa: '{layer_name}' | Campo catastral de NPN: '{field_name}'")

        if not layer_name or not field_name:
            log_warning("No se pudo iniciar la identificación espacial: falta seleccionar la capa o el campo del NPN.")
            QMessageBox.warning(self.iface.mainWindow(), "Selección Requerida", "Debes seleccionar una capa y campo de NPN activos.")
            self.dock.deactivate_map_tool()
            self.handle_map_tool_toggle(False)
            return

        # Buscar capa
        layer = None
        for lyr in QgsProject.instance().mapLayers().values():
            if lyr.name() == layer_name and lyr.type() == _VECTOR_LAYER_TYPE:
                layer = lyr
                break

        if not layer:
            log_warning(f"La capa seleccionada '{layer_name}' ya no existe en el proyecto.")
            QMessageBox.warning(self.iface.mainWindow(), "Error", "La capa seleccionada ya no existe.")
            return

        # Obtener los sistemas de referencia de coordenadas (CRS)
        canvas_crs = self.canvas.mapSettings().destinationCrs()
        layer_crs = layer.crs()
        
        # Transformar el punto de clic del CRS del canvas al CRS de la capa
        point_layer = point
        if canvas_crs != layer_crs:
            transform = QgsCoordinateTransform(canvas_crs, layer_crs, QgsProject.instance())
            try:
                point_layer = transform.transform(point)
                log_debug(f"Punto transformado de {canvas_crs.authid()} a {layer_crs.authid()}: ({point_layer.x():.6f}, {point_layer.y():.6f})")
            except Exception as e:
                log_error(f"Error al transformar las coordenadas del punto: {str(e)}")
                
        # Consulta espacial con buffer de tolerancia de clic según escala
        geom = QgsGeometry.fromPointXY(point_layer)
        
        # Calcular tolerancia en unidades de la capa
        # mapUnitsPerPixel da unidades del canvas por pixel. Convertimos aproximadamente
        pixel_tolerance = 6
        if canvas_crs == layer_crs:
            tolerance = self.canvas.mapUnitsPerPixel() * pixel_tolerance
        else:
            # Si los CRS difieren, estimamos la tolerancia transformando dos puntos cercanos
            try:
                p1 = self.canvas.mapSettings().mapToPixel().toMapCoordinates(0, 0)
                p2 = self.canvas.mapSettings().mapToPixel().toMapCoordinates(pixel_tolerance, 0)
                dist_canvas = p1.distance(p2)
                
                # Transformar p1 y p2 al CRS de la capa
                transform = QgsCoordinateTransform(canvas_crs, layer_crs, QgsProject.instance())
                p1_layer = transform.transform(p1)
                p2_layer = transform.transform(p2)
                tolerance = p1_layer.distance(p2_layer)
            except Exception:
                # Tolerancia por defecto en metros/grados según el CRS
                tolerance = 0.5 if layer_crs.isGeographic() else 5.0
                
        search_geom = geom.buffer(tolerance, 5)

        req = QgsFeatureRequest().setFilterRect(search_geom.boundingBox())
        features = layer.getFeatures(req)

        selected_feature = None
        for f in features:
            if f.geometry().intersects(search_geom):
                selected_feature = f
                break

        if not selected_feature:
            log_info("No se intersectó ninguna entidad geométrica bajo el punto de clic.")
            self.iface.messageBar().pushMessage(
                "NPN Decoder", 
                "No se encontró ningún predio en este punto del mapa.", 
                level=1, 
                duration=3
            )
            return

        # Seleccionar visualmente para dar retroalimentación
        layer.selectByIds([selected_feature.id()])

        # Extraer NPN
        try:
            npn_val = selected_feature[field_name]
        except KeyError:
            log_error(f"El campo catastral '{field_name}' no existe en los atributos de la entidad seleccionada.", exc_info=False)
            QMessageBox.warning(self.iface.mainWindow(), "Error", f"El campo '{field_name}' no existe en los atributos.")
            return

        # Poner en la caja de texto
        self.dock.input_npn.setText(str(npn_val))

        # --- CÁLCULO DE ÁREA Y CENTROIDE ELIPSOIDAL DEL PREDIO ---
        area_qgis, lat_qgis, lon_qgis = self.calculate_feature_area_and_centroid(selected_feature, layer)
        
        log_info(f"Entidad catastral identificada - ID: {selected_feature.id()} | NPN: '{npn_val}' | Área: {area_qgis} | Centroide: {lat_qgis}, {lon_qgis}")

        # --- EJECUTAR PROCESAMIENTO Y CONSULTA VUR ---
        self.process_npn_and_query_vur(str(npn_val), area_qgis, lat_qgis, lon_qgis)

    def decode_manual_npn(self, npn_str):
        """Maneja el desglose manual e intenta buscar en la capa activa para calcular el área catastral y centrar en QGIS."""
        log_info(f"Petición de desglose catastral manual recibida para NPN: '{npn_str}'")
        
        area_qgis = None
        lat_qgis = None
        lon_qgis = None
        
        # Intentar buscar el NPN en la capa seleccionada actualmente en el dock
        try:
            layer_name = self.dock.get_selected_layer()
            field_name = self.dock.get_selected_field()
            if layer_name and field_name:
                layer = None
                for lyr in QgsProject.instance().mapLayers().values():
                    if lyr.name() == layer_name and lyr.type() == _VECTOR_LAYER_TYPE:
                        layer = lyr
                        break
                if layer:
                    # Buscar la entidad con este NPN (escapando comillas simples para evitar inyección/rotura de sintaxis)
                    safe_npn = npn_str.replace("'", "''")
                    req = QgsFeatureRequest().setFilterExpression(f'"{field_name}" = \'{safe_npn}\'')
                    features = layer.getFeatures(req)
                    found = False
                    for f in features:
                        found = True
                        area_qgis, lat_qgis, lon_qgis = self.calculate_feature_area_and_centroid(f, layer)
                        
                        # Seleccionar visualmente en QGIS
                        layer.selectByIds([f.id()])
                        # Acercar la vista al predio seleccionado
                        self.canvas.zoomToSelected(layer)
                        log_info(f"Entidad manual encontrada en QGIS - ID: {f.id()} | Área: {area_qgis} | Centroide: {lat_qgis}, {lon_qgis}")
                        break
                    if not found:
                        log_info(f"El NPN manual '{npn_str}' no fue localizado espacialmente en la capa activa '{layer_name}'.")
        except Exception as e:
            log_error(f"Error al intentar buscar área espacial en QGIS para la búsqueda manual: {str(e)}")
            
        self.process_npn_and_query_vur(npn_str, area_qgis, lat_qgis, lon_qgis)

    def process_npn_and_query_vur(self, npn_str, area_qgis, lat_qgis=None, lon_qgis=None):
        """Ejecuta en paralelo el desglose del NPN, la consulta de la SNR (VUR) y de Colombia en Mapas (IGAC) para contrastar."""
        log_info(f"Iniciando procesamiento catastral trilateral para NPN: '{npn_str}' | Área QGIS: {area_qgis} | Centroide QGIS: {lat_qgis}, {lon_qgis}")
        
        # 1. Desglosar NPN Catastral (Pestaña 1)
        result = parse_npn(npn_str)
        log_debug(f"Resultado del desglose del NPN - Válido: {result['valid']} | Formato: {result.get('format')} | Error: {result.get('error')}")
        self.dock.display_npn_results(result)

        # 2. Consultar VUR SNR (Pestaña 2) e IGAC (Colombia en Mapas)
        npn_clean = clean_npn(npn_str)
        
        # Validar si el cliente está conectado o ejecutará la simulación de rigor
        is_demo = self.dock.chk_vur_demo.isChecked() or not self.vur_client.session_active
        
        # Obtener FMI manual si existe en la UI
        manual_fmi = self.dock.input_fmi.text().strip() if self.dock else ""
        
        QApplication.setOverrideCursor(Qt.WaitCursor)
        try:
            # Consultar VUR (Pasando FMI manual si lo ingresó el usuario)
            log_debug(f"Lanzando consulta registral a VUR. FMI Manual: '{manual_fmi}' | Modo Demo: {is_demo}")
            vur_data = self.vur_client.query_vur(npn_clean, is_demo=is_demo, manual_fmi=manual_fmi)
            
            # Consultar Colombia en Mapas (IGAC)
            log_debug("Lanzando consulta catastral a Colombia en Mapas (IGAC)...")
            igac_data = self.colombia_en_mapas_client.query_predio(npn_clean, is_demo=is_demo)
            
            # Si tenemos coordenadas calculadas en QGIS, las inyectamos como fallback en igac_data y vur_data
            if lat_qgis is not None and lon_qgis is not None:
                if igac_data and igac_data.get("success", False):
                    if not igac_data.get("latitud_centroide"):
                        igac_data["latitud_centroide"] = lat_qgis
                        igac_data["longitud_centroide"] = lon_qgis
                        log_debug("Inyectando coordenadas calculadas por QGIS en igac_data")
                if vur_data and vur_data.get("success", False):
                    if not vur_data.get("latitud_centroide"):
                        vur_data["latitud_centroide"] = lat_qgis
                        vur_data["longitud_centroide"] = lon_qgis
                        log_debug("Inyectando coordenadas calculadas por QGIS en vur_data")

            # Si el NPN no es válido en el parser, vaciamos la pestaña de comparación
            if not result["valid"]:
                log_warning(f"El NPN catastral '{npn_str}' es inválido. Cancelando comparación física y jurídica.")
                self.dock.display_vur_comparison(None, None, None)
                return
                
            # Renderizar comparación trilateral (QGIS vs VUR/SNR vs Colombia en Mapas)
            log_debug("Renderizando resultados en la interfaz del comparador...")
            self.dock.display_vur_comparison(area_qgis, vur_data, igac_data)
            
            # --- MICRO-INTERACCIÓN DE ALTO RIGOR ---
            # Si el VUR está activo y el predio tiene alertas críticas (Embargos),
            # mostramos una barra de mensajes del sistema en color rojo.
            if vur_data and vur_data.get("alertas_criticas"):
                alerts_str = ', '.join(vur_data['alertas_criticas'])
                log_warning(f"🚨 MEDIDAS CAUTELARES ENCONTRADAS en el Folio: {alerts_str}")
                self.iface.messageBar().pushMessage(
                    "🚨 SEGURIDAD JURÍDICA (VUR):", 
                    f"¡FOLIO CON ALERTA ACTIVA! {alerts_str}", 
                    level=2, # Nivel crítico/alerta en QGIS
                    duration=10
                )
                
            # Redirigir la pestaña del DockWidget automáticamente al Comparador para un UX interactivo
            if self.vur_client.session_active or is_demo:
                self.dock.tabs.setCurrentIndex(1) # Enfocar pestaña "⚖️ Comparar Registro"
                
        except Exception as e:
            log_error(f"Fallo no controlado en el flujo catastral trilateral: {str(e)}", exc_info=True)
        finally:
            QApplication.restoreOverrideCursor()

    # --- Control de Calidad por Lote ---

    def run_batch_validation(self, layer_name, field_name):
        log_info(f"Iniciando validación catastral masiva por lote (QC). Capa: '{layer_name}' | Campo: '{field_name}'")
        layer = None
        for lyr in QgsProject.instance().mapLayers().values():
            if lyr.name() == layer_name and lyr.type() == _VECTOR_LAYER_TYPE:
                layer = lyr
                break

        if not layer:
            log_warning(f"No se pudo ejecutar la validación masiva: la capa '{layer_name}' no existe.")
            return

        total_features = layer.featureCount()
        log_info(f"Capa catastral cargada con {total_features} entidades geográficas.")
        if total_features == 0:
            log_warning("La capa no contiene entidades catastrales para procesar.")
            return

        self.dock.progress_bar.setVisible(True)
        self.dock.progress_bar.setRange(0, total_features)
        self.dock.progress_bar.setValue(0)

        validos = 0
        invalidos = 0
        invalid_list = []

        features = layer.getFeatures()
        for idx, f in enumerate(features):
            self.dock.progress_bar.setValue(idx + 1)
            try:
                npn_val = f[field_name]
            except KeyError:
                log_warning(f"Entidad catastral FID {f.id()} no contiene el atributo seleccionado '{field_name}'. Omitiendo...")
                continue
            res = parse_npn(npn_val)
            if res["valid"]:
                validos += 1
            else:
                invalidos += 1
                invalid_list.append({
                    "fid": f.id(),
                    "npn": npn_val,
                    "error": res["error"]
                })

        log_info(f"Diagnóstico masivo completado. Total: {total_features} | Válidos: {validos} | Inválidos: {invalidos}")
        self.dock.display_qc_results(total_features, validos, invalidos, invalid_list)

    def add_qc_fields_to_layer(self, layer_name, field_name):
        log_info(f"Inyectando campos de control de calidad catastral (QC) en la capa: '{layer_name}'")
        layer = None
        for lyr in QgsProject.instance().mapLayers().values():
            if lyr.name() == layer_name and lyr.type() == _VECTOR_LAYER_TYPE:
                layer = lyr
                break

        if not layer:
            log_warning(f"Capa '{layer_name}' no encontrada para inyección QC.")
            return

        field_valid = QgsField("npn_valido", QVariant.Int, "Integer", 1)
        field_err = QgsField("npn_error", QVariant.String, "String", 200)

        fields_to_add = []
        existing_fields = [f.name() for f in layer.fields()]
        
        if "npn_valido" not in existing_fields:
            fields_to_add.append(field_valid)
        if "npn_error" not in existing_fields:
            fields_to_add.append(field_err)

        if fields_to_add:
            log_info(f"Inyectando nuevos atributos a la estructura de la capa: {[f.name() for f in fields_to_add]}")
            layer.startEditing()
            layer.addAttributes(fields_to_add)
            layer.commitChanges()

        idx_valido = layer.fields().indexOf("npn_valido")
        idx_error = layer.fields().indexOf("npn_error")

        if idx_valido == -1 or idx_error == -1:
            log_error("Fallo crítico al inicializar o inyectar las columnas 'npn_valido' y 'npn_error'.")
            QMessageBox.critical(self.iface.mainWindow(), "Error", "No se pudieron iniciar los campos QC.")
            return

        log_info("Comenzando el cálculo y actualización de atributos QC...")
        layer.startEditing()
        features = layer.getFeatures()
        updated_count = 0
        
        for f in features:
            try:
                npn_val = f[field_name]
            except KeyError:
                continue
            res = parse_npn(npn_val)
            valido_val = 1 if res["valid"] else 0
            error_val = "" if res["valid"] else res["error"]
            
            layer.changeAttributeValue(f.id(), idx_valido, valido_val)
            layer.changeAttributeValue(f.id(), idx_error, error_val)
            updated_count += 1

        if layer.commitChanges():
            log_info(f"Campos QC actualizados e inyectados con éxito en {updated_count} predios catastrales.")
            QMessageBox.information(
                self.iface.mainWindow(), 
                "Columnas QC Inyectadas", 
                f"Campos 'npn_valido' y 'npn_error' actualizados correctamente en {updated_count} predios.\n\n"
                f"Usa estos campos para clasificar y aplicar simbología temática en tu mapa de predios."
            )
            self.refresh_fields_combo()
        else:
            log_warning("No se pudieron guardar las actualizaciones de las columnas de control QC. Revirtiendo transacción...")
            layer.rollBack()
            QMessageBox.warning(self.iface.mainWindow(), "Error", "No se pudieron aplicar los cambios en la capa.")