/* global angular, moment, page_title */

// Controlador para el listado de movimientos de TAGs
angular.module("app").controller('MovimientosTagCtrl', [
    '$scope',
    '$window',
    'HikvisionService',
    function ($scope, $window, HikvisionService) {
        $window.document.title = page_title + " :: Registro de Movimientos de TAGs";
        
        // Inicialización de variables
        $scope.filtros = {
            fecha_inicio: moment().format('YYYY-MM-DD'),
            fecha_fin: moment().format('YYYY-MM-DD'),
            tag_id: null,
            device_id: null,
            tipo_movimiento: null,
            processed: null,
            access_result: null,
            door_id: null,
            numero_tag: null,
            limit: 50,
            offset: 0
        };
        
        $scope.moment_picker_fecha_inicio = moment();
        $scope.moment_picker_fecha_fin = moment();
        
        $scope.movimientos = [];
        $scope.dispositivos = [];
        $scope.total_registros = 0;
        $scope.loading = false;
        $scope.mensaje_error = null;
        $scope.movimiento_detalle = null;
        
        // Funciones para los date pickers
        $scope.on_change_moment_picker_fecha_inicio = function (newValue) {
            $scope.filtros.fecha_inicio = newValue.format('YYYY-MM-DD');
        };
        
        $scope.on_change_moment_picker_fecha_fin = function (newValue) {
            $scope.filtros.fecha_fin = newValue.format('YYYY-MM-DD');
        };
        
        // Carga inicial de dispositivos
        function cargarDispositivos() {
            HikvisionService.getAllDevices()
                .then(function(response) {
                    $scope.dispositivos = response.devices || [];
                })
                .catch(function(error) {
                    console.error('Error al cargar dispositivos:', error);
                    mostrarError('Error al cargar la lista de dispositivos');
                });
        }
        
        // Función principal de búsqueda
        $scope.buscarMovimientos = function () {
            $scope.loading = true;
            $scope.mensaje_error = null;
            
            var params = {
                fecha_inicio: $scope.filtros.fecha_inicio,
                fecha_fin: $scope.filtros.fecha_fin,
                limit: $scope.filtros.limit,
                offset: $scope.filtros.offset
            };
            
            // Añadir filtros opcionales
            if ($scope.filtros.tag_id) params.tag_id = $scope.filtros.tag_id;
            if ($scope.filtros.device_id) params.device_id = $scope.filtros.device_id;
            if ($scope.filtros.tipo_movimiento) params.tipo_movimiento = $scope.filtros.tipo_movimiento;
            if ($scope.filtros.processed !== null && $scope.filtros.processed !== '') params.processed = $scope.filtros.processed;
            if ($scope.filtros.access_result) params.access_result = $scope.filtros.access_result;
            if ($scope.filtros.door_id) params.door_id = $scope.filtros.door_id;
            if ($scope.filtros.numero_tag) params.numero_tag = $scope.filtros.numero_tag;
            
            HikvisionService.getMovements(params)
                .then(function (response) {
                    $scope.movimientos = response.movements || [];
                    $scope.total_registros = response.total || 0;
                    
                    if ($scope.movimientos.length === 0 && $scope.filtros.offset === 0) {
                        mostrarMensajeInfo('No se encontraron movimientos con los criterios especificados');
                    }
                })
                .catch(function (error) {
                    console.error('Error en búsqueda:', error);
                    $scope.mensaje_error = error.message || 'Error al obtener movimientos';
                    mostrarError($scope.mensaje_error);
                })
                .finally(function () {
                    $scope.loading = false;
                });
        };
        
        // Limpiar filtros
        $scope.limpiarFiltros = function() {
            $scope.filtros = {
                fecha_inicio: moment().format('YYYY-MM-DD'),
                fecha_fin: moment().format('YYYY-MM-DD'),
                tag_id: null,
                device_id: null,
                tipo_movimiento: null,
                processed: null,
                access_result: null,
                door_id: null,
                numero_tag: null,
                limit: 50,
                offset: 0
            };
            
            $scope.moment_picker_fecha_inicio = moment();
            $scope.moment_picker_fecha_fin = moment();
            
            $scope.buscarMovimientos();
        };
        
        // Funciones para estadísticas rápidas
        $scope.getCountByType = function(tipo) {
            return $scope.movimientos.filter(function(mov) {
                return mov.tipo_movimiento === tipo;
            }).length;
        };
        
        $scope.getCountByResult = function(result) {
            return $scope.movimientos.filter(function(mov) {
                return mov.access_result === result;
            }).length;
        };
        
        $scope.getCountByProcessed = function(processed) {
            return $scope.movimientos.filter(function(mov) {
                return mov.processed == processed;
            }).length;
        };
        
        // Paginación
        $scope.cambiarPagina = function(direccion) {
            var nuevaOffset = $scope.filtros.offset + (direccion * $scope.filtros.limit);
            if (nuevaOffset >= 0) {
                $scope.filtros.offset = nuevaOffset;
                $scope.buscarMovimientos();
            }
        };
        
        // Ver detalle del movimiento
        $scope.verDetalleMovimiento = function(movimiento) {
            $scope.movimiento_detalle = angular.copy(movimiento);
            $('#modalDetalleMovimiento').modal('show');
        };
        
        // Reprocesar movimiento
        $scope.reprocesarMovimiento = function(movimiento) {
            if (!movimiento.device_id) {
                mostrarError('No se puede reprocesar: falta información del dispositivo');
                return;
            }
            
            $scope.loading = true;
            
            var eventData = {
                card_no: movimiento.numero_tag,
                door_id: movimiento.door_id || 1,
                event_time: movimiento.fecha_movimiento,
                event_id: movimiento.isapi_event_id || 'manual_' + Date.now(),
                event_type: 'card_access'
            };
            
            HikvisionService.processAccessEvent(movimiento.device_id, eventData)
                .then(function(response) {
                    if (response.error) {
                        mostrarError('Error al reprocesar: ' + response.message);
                    } else {
                        mostrarMensajeExito('Movimiento reprocesado: ' + response.action);
                        $scope.buscarMovimientos(); // Recargar datos
                        $('#modalDetalleMovimiento').modal('hide');
                    }
                })
                .catch(function(error) {
                    mostrarError('Error al reprocesar movimiento: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // Sincronizar eventos recientes
        $scope.sincronizarEventos = function() {
            $scope.loading = true;
            
            HikvisionService.sincronizarHikvision(1) // Última hora
                .then(function(response) {
                    mostrarMensajeExito('Sincronización completada: ' + response.message);
                    $scope.buscarMovimientos(); // Recargar datos
                })
                .catch(function(error) {
                    mostrarError('Error al sincronizar: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // Exportar a Excel
        $scope.exportarExcel = function () {
            if ($scope.movimientos.length === 0) {
                mostrarMensajeInfo('No hay datos para exportar');
                return;
            }
            
            // Usar todos los filtros para la exportación, no solo los datos actuales
            var filtrosExportacion = angular.copy($scope.filtros);
            delete filtrosExportacion.limit;
            delete filtrosExportacion.offset;
            
            var url = HikvisionService.getExportExcelUrl(filtrosExportacion);
            $window.open(url, '_blank');
        };
        
        // Exportar a PDF
        $scope.exportarPdf = function () {
            if ($scope.movimientos.length === 0) {
                mostrarMensajeInfo('No hay datos para exportar');
                return;
            }
            
            // Usar todos los filtros para la exportación
            var filtrosExportacion = angular.copy($scope.filtros);
            delete filtrosExportacion.limit;
            delete filtrosExportacion.offset;
            
            var url = HikvisionService.getExportPdfUrl(filtrosExportacion);
            $window.open(url, '_blank');
        };
        
        // Funciones de mensajes
        function mostrarError(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'error',
                text: mensaje,
                layout: 'topRight',
                timeout: 4000
            }).show();
        }
        
        function mostrarMensajeInfo(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'info',
                text: mensaje,
                layout: 'topRight',
                timeout: 3000
            }).show();
        }
        
        function mostrarMensajeExito(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'success',
                text: mensaje,
                layout: 'topRight',
                timeout: 3000
            }).show();
        }
        
        // Inicialización
        cargarDispositivos();
        $scope.buscarMovimientos();
    }
]);

// Controlador para la configuración de dispositivos Hikvision
angular.module("app").controller('HikvisionConfigCtrl', [
    '$scope',
    '$window',
    'HikvisionService',
    function ($scope, $window, HikvisionService) {
        $window.document.title = page_title + " :: Configuración de Dispositivos Hikvision";
        
        $scope.dispositivos = [];
        $scope.loading = false;
        $scope.dispositivo_form = {};
        $scope.editando = false;
        
        // Función para cargar la lista de dispositivos
        function cargarDispositivos() {
            $scope.loading = true;
            HikvisionService.getAllDevices()
                .then(function(response) {
                    $scope.dispositivos = response.devices || [];
                })
                .catch(function(error) {
                    mostrarError('Error al cargar dispositivos: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        }
        
        // Inicializa el formulario para un nuevo dispositivo
        $scope.nuevoDispositivo = function() {
            $scope.dispositivo_form = HikvisionService.getDefaultDeviceConfig();
            $scope.editando = false;
        };
        
        // Carga los datos de un dispositivo existente para editar
        $scope.editarDispositivo = function(dispositivo) {
            $scope.dispositivo_form = angular.copy(dispositivo);
            $scope.editando = true;
        };
        
        // Guarda (crea o actualiza) un dispositivo
        $scope.guardarDispositivo = function() {
            // Validar configuración
            var validation = HikvisionService.validateDeviceConfig($scope.dispositivo_form);
            if (!validation.valid) {
                mostrarError('Errores en la configuración: ' + validation.errors.join(', '));
                return;
            }
            
            $scope.loading = true;
            
            var promise = $scope.editando ?
                HikvisionService.updateDevice($scope.dispositivo_form.id, $scope.dispositivo_form) :
                HikvisionService.registerDevice($scope.dispositivo_form);
            
            promise.then(function(response) {
                mostrarMensajeExito($scope.editando ? 
                    'Dispositivo actualizado correctamente' : 
                    'Dispositivo registrado correctamente');
                cargarDispositivos();
                $scope.nuevoDispositivo();
            })
            .catch(function(error) {
                mostrarError('Error al guardar dispositivo: ' + error.message);
            })
            .finally(function() {
                $scope.loading = false;
            });
        };
        
        // Prueba la conexión con un dispositivo
        $scope.probarConexion = function(dispositivo) {
            $scope.loading = true;
            
            HikvisionService.testDeviceConnection(dispositivo.id)
                .then(function(response) {
                    if (response.error) {
                        mostrarError('Error de conexión: ' + response.message);
                    } else {
                        mostrarMensajeExito('Conexión exitosa con el dispositivo');
                        console.log('Info del dispositivo:', response.device_info);
                    }
                })
                .catch(function(error) {
                    mostrarError('Error al probar conexión: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // Función para sincronizar con Hikvision
        $scope.sincronizarHikvision = function() {
            $scope.loading = true;
            
            HikvisionService.sincronizarHikvision(1) // Última hora
                .then(function(response) {
                    mostrarMensajeExito('Sincronización completada: ' + response.message);
                })
                .catch(function(error) {
                    mostrarError('Error al sincronizar con Hikvision: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // Funciones para mostrar notificaciones
        function mostrarError(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'error',
                text: mensaje,
                layout: 'topRight',
                timeout: 3000
            }).show();
        }
        
        function mostrarMensajeExito(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'success',
                text: mensaje,
                layout: 'topRight',
                timeout: 3000
            }).show();
        }
        
        // Inicialización
        cargarDispositivos();
        $scope.nuevoDispositivo();
    }
]);

// NUEVO: Controlador para Control de Acceso en Tiempo Real
angular.module("app").controller('ControlAccesoCtrl', [
    '$scope',
    '$window',
    '$interval',
    'HikvisionService',
    function ($scope, $window, $interval, HikvisionService) {
        $window.document.title = page_title + " :: Control de Acceso Hikvision";
        
        // Variables de estado
        $scope.dispositivos = [];
        $scope.dispositivo_seleccionado = null;
        $scope.eventos_recientes = [];
        $scope.estados_dispositivos = [];
        $scope.estadisticas = {
            total_movimientos: 0,
            movimientos_entrada: 0,
            movimientos_salida: 0,
            dispositivos_activos: 0
        };
        $scope.loading = false;
        $scope.auto_refresh = true;
        $scope.refresh_interval = 5; // segundos
        
        // Variables para verificar permisos (inicializar como array vacío si no existe)
        $scope.modulos_acciones_list = window.modulos_acciones_list || [];
        
        // Variables para control manual
        $scope.tag_manual = '';
        $scope.puerta_manual = 2;
        $scope.modo_puerta = 'normal';
        $scope.puerta_modo = 1;
        
        var refreshTimer = null;
        
        // ================== INICIALIZACIÓN ==================
        
        function init() {
            cargarDispositivos();
            cargarEstadisticas();
            iniciarMonitoreo();
        }
        
        function cargarDispositivos() {
            HikvisionService.getAllDevices()
                .then(function(response) {
                    $scope.dispositivos = response.devices || [];
                    if ($scope.dispositivos.length > 0 && !$scope.dispositivo_seleccionado) {
                        $scope.dispositivo_seleccionado = $scope.dispositivos[0];
                    }
                    verificarEstadoDispositivos();
                })
                .catch(function(error) {
                    mostrarError('Error al cargar dispositivos: ' + error.message);
                });
        }
        
        function cargarEstadisticas() {
            var hoy = moment().format('YYYY-MM-DD');
            
            HikvisionService.getAccessStats(hoy, hoy)
                .then(function(response) {
                    $scope.estadisticas = response.stats || {
                        total_movimientos: 0,
                        movimientos_entrada: 0,
                        movimientos_salida: 0,
                        dispositivos_activos: 0
                    };
                })
                .catch(function(error) {
                    console.error('Error al cargar estadísticas:', error);
                    // Mantener valores por defecto en caso de error
                    $scope.estadisticas = {
                        total_movimientos: 0,
                        movimientos_entrada: 0,
                        movimientos_salida: 0,
                        dispositivos_activos: 0
                    };
                });
        }
        
        // ================== MONITOREO EN TIEMPO REAL ==================
        
        function iniciarMonitoreo() {
            if (refreshTimer) {
                $interval.cancel(refreshTimer);
            }
            
            if ($scope.auto_refresh) {
                obtenerEventosRecientes();
                refreshTimer = $interval(function() {
                    if ($scope.auto_refresh) {
                        obtenerEventosRecientes();
                        verificarEstadoDispositivos();
                    }
                }, $scope.refresh_interval * 1000);
            }
        }
        
        function obtenerEventosRecientes() {
            HikvisionService.getRecentEvents(5) // Últimos 5 minutos
                .then(function(response) {
                    $scope.eventos_recientes = response.events || [];
                })
                .catch(function(error) {
                    console.error('Error al obtener eventos recientes:', error);
                });
        }
        
        function verificarEstadoDispositivos() {
            HikvisionService.checkAllDevicesStatus()
                .then(function(response) {
                    $scope.estados_dispositivos = response.devices_status || [];
                })
                .catch(function(error) {
                    console.error('Error al verificar estado de dispositivos:', error);
                });
        }
        
        $scope.toggleAutoRefresh = function() {
            $scope.auto_refresh = !$scope.auto_refresh;
            iniciarMonitoreo();
        };
        
        $scope.cambiarIntervalo = function(segundos) {
            $scope.refresh_interval = segundos;
            iniciarMonitoreo();
        };
        
        // ================== CONTROL MANUAL DE PUERTAS ==================
        
        $scope.abrirPuerta = function(device_id, door_id) {
            if (!device_id) {
                mostrarError('Selecciona un dispositivo primero');
                return;
            }
            
            $scope.loading = true;
            var reason = 'Apertura manual desde panel de control';
            
            HikvisionService.openDoor(device_id, door_id || 2, reason)
                .then(function(response) {
                    if (response.error) {
                        mostrarError('Error al abrir puerta: ' + response.message);
                    } else {
                        mostrarMensajeExito('Puerta ' + (door_id || 2) + ' abierta correctamente');
                        // Actualizar eventos inmediatamente
                        obtenerEventosRecientes();
                    }
                })
                .catch(function(error) {
                    mostrarError('Error al abrir puerta: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        $scope.cambiarModoPuerta = function() {
            if (!$scope.dispositivo_seleccionado) {
                mostrarError('Selecciona un dispositivo primero');
                return;
            }
            
            $scope.loading = true;
            
            HikvisionService.setDoorMode($scope.dispositivo_seleccionado.id, $scope.modo_puerta, $scope.puerta_modo)
                .then(function(response) {
                    if (response.error) {
                        mostrarError('Error al cambiar modo: ' + response.message);
                    } else {
                        mostrarMensajeExito('Modo de puerta cambiado a: ' + $scope.modo_puerta);
                    }
                })
                .catch(function(error) {
                    mostrarError('Error al cambiar modo: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // ================== VALIDACIÓN Y SIMULACIÓN DE TAGS ==================
        
        $scope.validarTag = function() {
            if (!$scope.tag_manual) {
                mostrarError('Ingresa un número de TAG');
                return;
            }
            
            $scope.loading = true;
            
            HikvisionService.validateTag($scope.tag_manual)
                .then(function(response) {
                    if (response.valid) {
                        mostrarMensajeExito('TAG válido - Acceso: ' + (response.access_granted ? 'PERMITIDO' : 'DENEGADO'));
                        console.log('Datos del TAG:', response.tag_data);
                    } else {
                        mostrarError('TAG no válido en el sistema');
                    }
                })
                .catch(function(error) {
                    mostrarError('Error al validar TAG: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        $scope.simularAccesoTag = function() {
            if (!$scope.tag_manual) {
                mostrarError('Ingresa un número de TAG');
                return;
            }
            
            if (!$scope.dispositivo_seleccionado) {
                mostrarError('Selecciona un dispositivo');
                return;
            }
            
            $scope.loading = true;
            
            HikvisionService.simulateTagAccess($scope.dispositivo_seleccionado.id, $scope.tag_manual)
                .then(function(response) {
                    if (response.success) {
                        mostrarMensajeExito('Simulación exitosa: ' + response.message);
                        if (response.action_taken === 'DOOR_OPENED') {
                            mostrarMensajeInfo('Barrera abierta automáticamente');
                        }
                    } else {
                        mostrarError('Acceso denegado: ' + response.message);
                    }
                    
                    // Actualizar eventos
                    obtenerEventosRecientes();
                })
                .catch(function(error) {
                    mostrarError('Error en simulación: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // ================== GESTIÓN DE EVENTOS ==================
        
        $scope.obtenerEventosDispositivo = function(device_id) {
            if (!device_id) return;
            
            $scope.loading = true;
            var timeRange = HikvisionService.getTimeRangeForISAPI(60); // Última hora
            
            HikvisionService.getDeviceEvents(device_id, timeRange.start_time, timeRange.end_time)
                .then(function(response) {
                    if (response.error) {
                        mostrarError('Error al obtener eventos: ' + response.message);
                    } else {
                        mostrarMensajeInfo('Eventos obtenidos: ' + response.total);
                        // Actualizar eventos recientes
                        obtenerEventosRecientes();
                    }
                })
                .catch(function(error) {
                    mostrarError('Error al obtener eventos: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        $scope.procesarEventoManual = function(evento) {
            if (!$scope.dispositivo_seleccionado) {
                mostrarError('Selecciona un dispositivo');
                return;
            }
            
            $scope.loading = true;
            
            HikvisionService.processAccessEvent($scope.dispositivo_seleccionado.id, evento)
                .then(function(response) {
                    if (response.error) {
                        mostrarError('Error al procesar evento: ' + response.message);
                    } else {
                        mostrarMensajeExito('Evento procesado: ' + response.action);
                    }
                })
                .catch(function(error) {
                    mostrarError('Error al procesar evento: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // Función adicional para sincronizar eventos (llamada desde la vista)
        $scope.sincronizarEventos = function() {
            $scope.loading = true;
            
            HikvisionService.sincronizarHikvision(1) // Última hora
                .then(function(response) {
                    mostrarMensajeExito('Sincronización completada: ' + response.message);
                    // Actualizar eventos y estadísticas
                    obtenerEventosRecientes();
                    cargarEstadisticas();
                })
                .catch(function(error) {
                    mostrarError('Error al sincronizar: ' + error.message);
                })
                .finally(function() {
                    $scope.loading = false;
                });
        };
        
        // ================== UTILIDADES ==================
        
        $scope.formatearFecha = function(fecha) {
            if (!fecha) return '';
            return moment(fecha).format('DD/MM/YYYY HH:mm:ss');
        };
        
        $scope.getStatusColor = function(status) {
            switch(status) {
                case 'online': return 'success';
                case 'offline': return 'danger';
                case 'error': return 'warning';
                default: return 'secondary';
            }
        };
        
        $scope.getEventTypeColor = function(eventType) {
            switch(eventType) {
                case 'ENTRADA': return 'success';
                case 'SALIDA': return 'danger';
                case 'ACCESS_DENIED': return 'warning';
                default: return 'info';
            }
        };
        
        // Función para verificar permisos (evita errores si no existe modulos_acciones_list)
        $scope.hasPermission = function(permiso) {
            if (!$scope.modulos_acciones_list || !Array.isArray($scope.modulos_acciones_list)) {
                return true; // Por defecto permitir si no hay sistema de permisos configurado
            }
            return $scope.modulos_acciones_list.indexOf(permiso) !== -1;
        };
        
        // Función para obtener tiempo actual (evita problemas con new Date() en la vista)
        $scope.getCurrentTime = function() {
            return moment().format('DD/MM/YYYY HH:mm:ss');
        };
        
        // ================== FUNCIONES DE MENSAJES ==================
        
        function mostrarError(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'error',
                text: mensaje,
                layout: 'topRight',
                timeout: 4000
            }).show();
        }
        
        function mostrarMensajeExito(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'success',
                text: mensaje,
                layout: 'topRight',
                timeout: 3000
            }).show();
        }
        
        function mostrarMensajeInfo(mensaje) {
            new Noty({
                theme: 'bootstrap-v4',
                type: 'info',
                text: mensaje,
                layout: 'topRight',
                timeout: 3000
            }).show();
        }
        
        // ================== LIMPIEZA ==================
        
        $scope.$on('$destroy', function() {
            if (refreshTimer) {
                $interval.cancel(refreshTimer);
            }
        });
        
        // Inicialización
        init();
    }
]);

// NUEVO: Controlador básico para Logs de Acceso
angular.module("app").controller('AccessLogsCtrl', [
    '$scope',
    '$window',
    'HikvisionService',
    function ($scope, $window, HikvisionService) {
        $window.document.title = page_title + " :: Logs de Acceso Hikvision";
        
        // Este controlador será expandido en futuras versiones
        $scope.message = "Logs de acceso disponibles próximamente";
    }
]);

// NUEVO: Controlador básico para Configuración ISAPI
angular.module("app").controller('IsapiConfigCtrl', [
    '$scope',
    '$window',
    'HikvisionService',
    function ($scope, $window, HikvisionService) {
        $window.document.title = page_title + " :: Configuración ISAPI Hikvision";
        
        // Este controlador será expandido en futuras versiones
        $scope.message = "Configuración ISAPI disponible próximamente";
    }
]);