(function () {
    'use strict';

    angular
        .module('setoresApp')
        .directive('tratamentoAlarmes', tratamentoAlarmes);

    tratamentoAlarmes.$inject = ['__env', 'FormValidation', 'ngNotify', '$location', 'gridAlarmes', 'setoresServiceFactory',
        'infowindowTemplates', 'userMessages', '$compile', '$timeout', 'utilsFactory', 'mapsSingletonService'];

    /* @ngInject */
    function tratamentoAlarmes(__env, FormValidation, ngNotify, $location, gridAlarmes, setoresServiceFactory,
        infowindowTemplates, userMessages, $compile, $timeout, utilsFactory, mapsSingletonService) {

        return {
            link: link,
            restrict: 'A',
            replace: false,
            scope: false
        };

        function link(scope) {
            let _urlParams = $location.$$search;
            angular.extend(scope.vm, {
                carregarAlarmes: carregarAlarmes,
                carregarAlarmesPendentes: carregarAlarmesPendentes,
                fecharModalTratarAlarmes: fecharModalTratarAlarmes,
                trocarContextoModal: trocarContextoModal,
                tratarAlarme: tratarAlarme,
                toggleTodosAlarmesPacman: toggleTodosAlarmesPacman,
                toggleAlarmesPacman: toggleAlarmesPacman,
                fecharPromptTipoAlarme: fecharPromptTipoAlarme,
                aplicarJustificativasAlarmePacman: aplicarJustificativasAlarmePacman
            });

            let statusAlarmes = {
                abonado: 'A',
                penalizado: 'F',
                invalido: 'I',
                pendente: 'P'
            };

            let alarmesSelecionados = [];

            scope.vm.alarmeTratar = null;

            /* ------------- GRID DE ALARMES ------------- */
            function carregarAlarmes() {
                switch (scope.vm.tabActive) {
                    case 'pendentes': carregarAlarmesPendentes(); break;
                    case 'válidos': carregarAlarmesValidos(); break;
                    case 'inválidos': carregarAlarmesInvalidos(); break;
                    default: break;
                }
            }

            function carregarAlarmesPendentes() {
                if (!scope.vm.veiculos) {
                    carregarSetoresDescumpridosAlarmes();
                    return;
                }

                scope.vm.showLoadingFooter();
                setoresServiceFactory.carregarAlarmes(_urlParams.codigoSetor, _urlParams.dt, scope.vm.veiculos, statusAlarmes.pendente)
                    .then(result => {
                        scope.vm.gridAlarmesPendentes = null;
                        successCarregarAlarmes(result, 'gridAlarmesPendentes');
                        carregarSetoresDescumpridosAlarmes();
                    })
                    .catch(errorRequest);
            }

            function carregarSetoresDescumpridosAlarmes() {
                setoresServiceFactory.carregarSetoresDescumpridosAlarmes(_urlParams.codigoSetor, _urlParams.dt)
                    .then(result => addSetoresDescumpridosAlarmes(result))
                    .catch(errorRequest);
            }

            function carregarAlarmesValidos() {
                if (!scope.vm.veiculos) {
                    carregarSetoresDescumpridosAlarmes();
                    return;
                }
                scope.vm.showLoadingFooter();
                setoresServiceFactory.carregarAlarmes(_urlParams.codigoSetor, _urlParams.dt, scope.vm.veiculos, `${statusAlarmes.penalizado};${statusAlarmes.abonado}`)
                    .then(result => {
                        scope.vm.gridAlarmesValidos = null;
                        successCarregarAlarmes(result, 'gridAlarmesValidos');
                    })
                    .catch(errorRequest);
            }

            function carregarAlarmesInvalidos() {
                if (!scope.vm.veiculos) {
                    carregarSetoresDescumpridosAlarmes();
                    return;
                }
                scope.vm.showLoadingFooter();
                setoresServiceFactory.carregarAlarmes(_urlParams.codigoSetor, _urlParams.dt, scope.vm.veiculos, statusAlarmes.invalido)
                    .then(result => {
                        scope.vm.gridAlarmesInvalidos = null;
                        successCarregarAlarmes(result, 'gridAlarmesInvalidos');
                        carregarSetoresDescumpridosAlarmes();
                    })
                    .catch(errorRequest);
            }

            function successCarregarAlarmes(result, gridScope) {
                let take = 10;
                let skip = 10;
                let gridQuerying = false;

                let data = result.data;
                let columns = gridAlarmes.getColumns();
                let options = gridAlarmes.getOptions();

                scope.vm.abasGridCarregada = true;
                scope.vm[gridScope] = new GridModel(data, columns, options, 'Codigo');
                scope.vm[gridScope].customOptions = gridAlarmes.getCustomOptions();

                // Eventos interação com a grid de alarmes
                scope.vm[gridScope].onSelectedRowsChanged = (e, args) => {
                    let columnBtnConfig = args.grid.getColumns().find(item => item.id === 'BtnConfig');
                    let columnConfig = scope.vm[gridScope].grid.getColumns().find(item => item.id === 'BtnConfig');
                    let selectedRows = args.grid.getSelectedRows();
                    scope.vm[gridScope].setSelectData(selectedRows);

                    if (scope.vm[gridScope].selectedData.length > 0) {
                        columnConfig.header.buttons[0].cssClass = columnConfig.header.buttons[0].cssClass.replace(' btn-disabled', '');
                        let item = scope.vm[gridScope].grid.getDataItem(selectedRows[0]);

                        if (scope.vm[gridScope].selectedData.length === 1) {
                            scope.vm.checkedAlarmeType = item.IdentificadorDE + item.CodigoSetorCumprimento;
                        } else if (args.rows.length > 1 && !scope.vm.checkedAlarmeType) {
                            scope.vm.checkedAlarmeType = item.IdentificadorDE + item.CodigoSetorCumprimento;
                        }
                        columnBtnConfig.disabled = true;
                    }
                    else {
                        scope.vm.checkedAlarmeType = null;
                        columnConfig.header.buttons[0].cssClass += ' btn-disabled';
                        columnBtnConfig.disabled = false;
                    }

                    args.grid.invalidate();
                    args.grid.updateColumnHeader(columnConfig.id);
                };

                scope.vm[gridScope].onHeaderClick = (e, args) => {
                    if (args.column.id === '_checkbox_selector') {
                        let selectedItens = scope.vm[gridScope].data.map((item, idx) => {
                            if ((item.IdentificadorDE + item.CodigoSetorCumprimento) === scope.vm.checkedAlarmeType) {
                                return idx;
                            }
                        }).filter(x => x !== undefined);

                        if ($(e.target).is(":checked")) {
                            args.grid.setSelectedRows(selectedItens);
                            let id = $(args.column.name)[0].id;
                            $(`#${id}`).prop('checked', 'checked');
                        }
                        else args.grid.setSelectedRows([]);
                    }
                };

                scope.vm[gridScope].onClick = (e, args) => {
                    if (e.target.classList.contains('btn-view') || e.target.parentElement.classList.contains('btn-view')) {
                        scope.vm.showLoadingFooter();
                        setoresServiceFactory.carregarContextoAlarme(scope.vm[gridScope].data[args.row].Codigo)
                            .then(successCarregarContextoAlarme)
                            .catch(errorRequest);
                    }

                    if (e.target.classList.contains('btn-config') || e.target.parentElement.classList.contains('btn-config')) {
                        scope.vm.alarmeTratar = scope.vm[gridScope].data[args.row];
                        scope.vm.alarmePacman = scope.vm.alarmeTratar.CodigoSetorCumprimento !== null;
                        alarmesSelecionados = [scope.vm.alarmeTratar.Codigo];

                        if (scope.vm.alarmeTratar.AlarmeSetorDescumprido) {
                            scope.vm.abrirModalEdicaoApontamentos();
                        } else if (scope.vm.alarmePacman && !scope.vm.setorEmExecucao) {
                            abrirPromptTipoAlarme();
                        } else {
                            abrirModalTratarAlarmes(scope.vm.alarmeTratar);
                        }
                    }
                };

                scope.vm[gridScope].onHeaderBtnClick = (e, args) => {
                    if (e.target.classList.contains('btn-config-group') || e.target.parentElement.classList.contains('btn-config-group')) {
                        if (e.target.classList.contains('btn-disabled') || e.target.parentElement.classList.contains('btn-disabled')) {
                            return false;
                        } else {
                            scope.vm.alarmePacman = scope.vm[gridScope].selectedData.some(item => item.CodigoSetorCumprimento !== null);
                            alarmesSelecionados = scope.vm[gridScope].selectedData.map(alarme => alarme.Codigo);
                            abrirModalTratarAlarmes(scope.vm[gridScope].selectedData[0]);
                        }
                    }

                    args.grid.invalidate();
                };

                scope.vm[gridScope].onScroll = (e, args) => {
                    if (!gridQuerying) {
                        //Todo: bug - grid faz a consulta ao reordenar as colunas pela primeira vez:
                        // http://localhost:5936/Rastreamento/Apresentacao/Setores/Setores/Detalhes?codigoSetor=2954&dt=2018-02-14T02:00:00.000Z
                        if (args.grid.getViewport().bottom === skip) {
                            gridQuerying = true;
                            scope.vm.showLoadingFooter();

                            let status = gridScope === 'gridAlarmesPendentes' ? statusAlarmes.pendente : (gridScope === 'gridAlarmesInvalidos' ?
                                statusAlarmes.invalido : `${statusAlarmes.penalizado};${statusAlarmes.abonado}`);

                            setoresServiceFactory.carregarAlarmes(_urlParams.codigoSetor, _urlParams.dt, scope.vm.veiculos, status, take, skip)
                                .then((result) => {
                                    result.data.forEach(item => {
                                        args.grid.getData().addItem(item);
                                        args.grid.getData().refresh();
                                    });

                                    skip += take;
                                    gridQuerying = false;
                                    scope.vm.hideLoadingFooter();
                                }).catch(errorRequest);
                        }
                    }
                };

                scope.vm.hideLoadingFooter();
            }

            function addSetoresDescumpridosAlarmes(result) {
                if (result.data !== null && result.data !== 'null') {
                    const alarme = result.data;
                    alarme.Codigo = utilsFactory.gerarUuidv4();
                    alarme.Descricao = 'Setor não cumprido';
                    alarme.AlarmeSetorDescumprido = true;
                    alarme.DataHoraFormatado = new Date(result.data.DataHoraNaoExecucao).toLocaleString();

                    let alarmes = !scope.vm.veiculos ? (scope.vm.gridAlarmesPendentes || {}).data : (scope.vm.gridAlarmesInvalidos || {}).data;
                    alarmes = (alarmes || []).filter(x => !x.AlarmeSetorDescumprido).concat(alarme);
                    result.data = alarmes;
                    successCarregarAlarmes(result, scope.vm.veiculos ? 'gridAlarmesInvalidos' : 'gridAlarmesPendentes');
                }
            }

            /* ------------- PLOTAR ALARMES ------------- */
            function successCarregarContextoAlarme(result) {
                if (result && result.data) {
                    let alarme = result.data;

                    if (alarme && alarme.Maiores.length > 0 && alarme.Menores.length > 0) {
                        if (alarme.VeiculoAlarme.CodigoSetorCumprimento) {
                            setoresServiceFactory.carregarPacmansNaoCumpridos(alarme.VeiculoAlarme.CodigoSetorCumprimento, alarme.VeiculoAlarme.CodigoVeiculo)
                                .then((result) => successCarregarPacmansNaoCumpridos(result, alarme.VeiculoAlarme))
                                .catch(errorRequest);
                        } else {
                            const map = mapsSingletonService.getMap();
                            let clearParams = { alarmePacman: false };
                            clearAlarmesPolyline(clearParams);
                            scope.vm.showCustomNotification('Visualização de alarme', 'icon-eye', 'info', clearAlarmesPolyline, clearParams);

                            const polyline = [];
                            const ptosMenores = [];
                            const ptosMaiores = [];
                            const infowindows = [];

                            alarme.Menores.forEach(historico => {
                                let ponto = [historico.Latitude / 1000000, historico.Longitude / 1000000];
                                infowindows.push(infowindowTemplates.montarInfoWindowTrajeto(historico.InfoWindow));
                                polyline.push(ponto);
                                ptosMenores.push(ponto);
                            });

                            const optionsMenores = new InlogMaps.PolylineOptions(ptosMenores, true, false, false, false, '#00FF00', 10);
                            optionsMenores.opacity = 0.4;
                            optionsMenores.zIndex = 4;
                            map.drawPolyline('highlightMenores', optionsMenores);

                            alarme.Maiores.forEach(historico => {
                                let ponto = [historico.Latitude / 1000000, historico.Longitude / 1000000];
                                infowindows.push(infowindowTemplates.montarInfoWindowTrajeto(historico.InfoWindow));
                                polyline.push(ponto);
                                ptosMaiores.push(ponto);
                            });

                            const optionsMaiores = new InlogMaps.PolylineOptions(ptosMaiores, true, false, false, false, '#FF00FF', 10);
                            optionsMaiores.opacity = 0.4;
                            optionsMaiores.zIndex = 3;
                            map.drawPolyline('highlightMaiores', optionsMaiores);

                            const options = new InlogMaps.PolylineOptions(polyline, true, true, false, false, '#FF0000', 2);
                            options.opacity = 0.75;
                            options.zIndex = 5;
                            options.infowindows = infowindows;
                            options.navigateOptions = new InlogMaps.NavigationOptions('#000', 5, false);
                            map.drawPolylineWithNavigation('alarme', options);

                            const markerOptions = new InlogMaps.MarkerOptions([alarme.Latitude, alarme.Longitude], true);
                            markerOptions.object = {
                                descricao: alarme.Descricao,
                                data: alarme.DataHora,
                                info: alarme.InformacoesAdicionais
                            };
                            map.drawMarker('alarme', markerOptions, onClickMarkerAlarme);
                        }
                    }
                }
                scope.vm.hideLoadingFooter();
            }

            function clearAlarmesPolyline(params) {
                const map = mapsSingletonService.getMap();
                map.closePopup('pontoParada');
                map.removePolylineHighlight();

                if (params.alarmePacman) {
                    map.removeMarkers('pacmanAlarme');
                    map.closePopup('pacmanAlarme');

                    scope.vm.camadas.filter(item => item.tipoCamada === scope.vm.tipoCamada.veiculos).forEach(camada => {
                        camada.checked = false;
                        scope.vm.toggleTodos(camada);
                    });
                } else {
                    map.removePolylines('highlightMenores');
                    map.removePolylines('highlightMaiores');
                    map.removePolylines('alarme');
                    map.removeMarkers('alarme');
                    map.closePopup('alarme');
                }
            }

            async function successCarregarPacmansNaoCumpridos(result, alarme) {
                if (result && result.data) {
                    if (result.data.Pacmans) {
                        let clearParams = { alarmePacman: true };
                        clearAlarmesPolyline(clearParams);
                        scope.vm.showCustomNotification('Visualização de alarme', 'icon-eye', 'info', clearAlarmesPolyline, clearParams);

                        await Promise.all(result.data.Pacmans.map(async pacman => {
                            let myLatlng = [pacman.Latitude / 1000000, pacman.Longitude / 1000000];

                        let infoMarker = {
                            visivel: pacman.DescricaoJustObservacao !== "",
                            justificativa: pacman.DescricaoJustObservacao,
                            observacao: pacman.Observacao,
                            sequencia: pacman.Sequencia,
                            rua: pacman.Rua,
                            transversalInicio: pacman.TransversalInicio,
                            transversalFim: pacman.TransversalFim,
                            tipo: pacman.Tipo,
                            codigoAlarme: [alarme.Codigo],
                            alarme: alarme,
                            codigoPacman: pacman.Codigo
                        };

                        const urlIcon = pacman.DescricaoJustObservacao ? `${__env.baseUrl}/Setores/SetoresSource/MontarIconeMarkerAzul` :
                            `${__env.baseUrl}/Setores/SetoresSource/MontarIconeMarker?itemSelecionado=false&itemContestado=true&sequencia=${pacman.Sequencia}`;
                        const urlSize = await mapsSingletonService.getIconSize(urlIcon);

                        const options = new InlogMaps.MarkerOptions(myLatlng, true);
                        options.object = infoMarker;
                        options.icon = new InlogMaps.MarkerIcon(urlIcon, urlSize);
                        mapsSingletonService.getMap().drawMarker('pacmanAlarme', options, onClickPacmanAlarme);
                    }));

                    // Habilita a camada com o histórico do veículo
                    let camadas = scope.vm.camadas.filter(item => item.tipoCamada === scope.vm.tipoCamada.veiculos);
                    camadas.forEach(camada => {
                        camada.checked = true;
                        scope.vm.toggleTodos(camada);
                    });
                }
            }
            scope.vm.hideLoadingFooter();
        }

        function onClickMarkerAlarme(event, object) {
            const options = new InlogMaps.PopupOptions();
            options.marker = 'alarme';
            options.content = infowindowTemplates.montarInfoWindowAlarme(object);

            mapsSingletonService.getMap().drawPopup('alarme', options);
        }

        function onClickPacmanAlarme(event, object) {
            const options = new InlogMaps.PopupOptions();
            options.marker = 'pacmanAlarme';
            options.conditionMarker = (item) => item.codigoPacman === object.codigoPacman;
            options.content = $compile(infowindowTemplates.montarInfoWindowPacmanAlarme(object))(scope)[0];

            mapsSingletonService.getMap().drawPopup('pacmanAlarme', options);
        }

        /* ------------- TRATAMENTO DE ALARMES ------------- */

        function abrirPromptTipoAlarme() {
            scope.vm.tipoErroApontamento = null;

                scope.vm.openModal('Alarme de quebra de planejamento',
                    __env.appPath + 'scripts/partials/prompt/prompt-tipo-alarme.html', fecharPromptTipoAlarme, true)
                    .then(() => {
                        scope.vm.hideLoading();
                    });
            }

            function fecharPromptTipoAlarme() {
                scope.vm.closeModal()
                    .then(() => scope.vm.tipoErroApontamento = null);
            }

        function trocarContextoModal(tipoErroApontamento) {
            if (tipoErroApontamento) {
                scope.vm.abrirModalEdicaoApontamentos();
            } else {
                abrirModalTratarAlarmes(scope.vm.alarmeTratar);
            }
        }

            function abrirModalTratarAlarmes(alarme) {
                scope.vm.showLoading();
                let params = {
                    RegraOrigem: alarme.IdentificadorDE,
                    CodigosAlarmes: alarmesSelecionados,
                    EditarAlarme: alarme.Status !== statusAlarmes.pendente,
                    AlarmePacman: alarme.CodigoSetorCumprimento && alarme.CodigoSetorCumprimento > 0,
                    CodigoSetorCumprimento: alarme.CodigoSetorCumprimento,
                    CodigoSetor: _urlParams.codigoSetor,
                    DataCumprimento: _urlParams.dt,
                    ConnectionId: '123',
                    CodigoVeiculo: alarme.CodigoVeiculo
                };

            setoresServiceFactory.carregarJustificativasTratamentoAlarme(params)
                .then((result) => successCarregarJustificativasTratamentoAlarme(result, alarme))
                .catch(errorRequest);
        }

        function successCarregarJustificativasTratamentoAlarme(result, alarme) {
            if (result.data) {
                if (result.data.MensagemTravaAlarme) {
                    scope.vm.hideLoading();
                    ngNotify.set(result.data.MensagemTravaAlarme, {
                        type: 'warn',
                        sticky: true
                    });
                } else {
                    scope.vm.tratamentoAlarme = result.data;

                    switch (alarme.Status) {
                        case statusAlarmes.pendente:
                        case statusAlarmes.invalido:
                            scope.vm.tratamentoAlarme.validacaoAlarme = false;
                            scope.vm.tratamentoAlarme.acaoAlarme = true;
                            break;
                        case statusAlarmes.abonado:
                            scope.vm.tratamentoAlarme.validacaoAlarme = true;
                            scope.vm.tratamentoAlarme.acaoAlarme = false;
                            break;
                        case statusAlarmes.penalizado:
                            scope.vm.tratamentoAlarme.validacaoAlarme = true;
                            scope.vm.tratamentoAlarme.acaoAlarme = true;
                            break;
                        default:
                            break;
                    }

                    scope.vm.alarmePacmanTodos = false;
                    scope.vm.justificativaPacmansSelecionados = '';
                    scope.vm.observacaoPacmansSelecionados = '';

                        if (scope.vm.tratamentoAlarme.OcorrenciasNavegador && scope.vm.tratamentoAlarme.OcorrenciasNavegador.length) {
                            preencheInfosOcorrenciaNavegador(scope.vm.tratamentoAlarme.OcorrenciasNavegador);
                        }

                        scope.vm.openModal('Tratamento de alarmes', __env.appPath + 'scripts/partials/modal/modal-tratamento-de-alarmes.html', fecharModalTratarAlarmes, true)
                            .then(() => {
                                scope.vm.validationFormTratarAlarme = new FormValidation(scope.vm.formTratarAlarmes);
                                scope.vm.validationFormTratarAlarme.setControlsValidation(scope.vm.validacaoGrupoTrechosTratamentoAlarme);
                                scope.vm.hideLoading();
                            });
                    }
                } else {
                    scope.vm.hideLoading();
                    ngNotify.set(userMessages.JUSTIFICATIVAS_NAO_ENCONTRADAS, {
                        type: 'error',
                        sticky: true
                    });
                }
            }

            function fecharModalTratarAlarmes() {
                let params = {
                    ConnectionID: '123',
                    CodigosAlarmes: alarmesSelecionados
                };
                setoresServiceFactory.removerAlarmeCache(params)
                    .then(() => {
                        scope.vm.closeModal().then(() => {
                            scope.vm.tratamentoAlarme = {};
                            scope.vm.contemTrechosInvalidosTramamentoAlarmes = false;
                            alarmesSelecionados = [];
                        });
                    }).catch(errorRequest);
            }

        function tratarAlarme() {
            scope.vm.tratamentoAlarme.ConnectionID = '123';
            scope.vm.tratamentoAlarme.StatusSelecionado = scope.vm.tratamentoAlarme.validacaoAlarme ?
                (scope.vm.tratamentoAlarme.acaoAlarme ? statusAlarmes.penalizado : statusAlarmes.abonado) : statusAlarmes.invalido;

            scope.vm.setFormStatus(scope.vm.formTratarAlarmes, 'SENDING').then(() => {
                setoresServiceFactory.tratarEditarAlarmesSetor(scope.vm.tratamentoAlarme)
                    .then(successTratarEditarAlarmesSetor)
                    .catch(errorRequest);
            });

        }

            function successTratarEditarAlarmesSetor(result) {
                if (result.data.Sucesso) {
                    scope.vm.setFormStatus(scope.vm.formTratarAlarmes, 'SEND_SUCCESS').then(() => {
                        ngNotify.set(result.data.MensagemSucesso, {
                            type: 'success',
                            sticky: false
                        });
                        carregarAlarmes();
                        clearAlarmesPolyline({ alarmePacman: true });

                    if (result.data.Objeto.length > 0 && result.data.Objeto[0].CodigoSetorCumprimento) {
                        // Plotar novamente as justificativas
                        scope.vm.carregarJustificativasSetor();
                    }

                        fecharModalTratarAlarmes();
                    });
                } else {
                    scope.vm.setFormStatus(scope.vm.formTratarAlarmes, 'SEND_FAIL').then(() => {
                        ngNotify.set(result.data.MensagemErro, {
                            type: 'error',
                            sticky: true
                        });
                    });

                    $timeout(() => scope.vm.setFormStatus(scope.vm.formTratarAlarmes, null), 1000);
                }
            }

            function preencheInfosOcorrenciaNavegador(ocorrencia) {
                scope.vm.tratamentoAlarme.ListaTrechos.forEach(trecho => {
                    const trechoOcorrencia = ocorrencia.find(x => x.CodigoTrecho == trecho.CodigoTrecho);

                    if (trechoOcorrencia) {
                        trecho.JustificativaTrechoSelecionada = trechoOcorrencia.CodigoViaObstruida.toString();
                        trecho.DescricaoJustObservacao = trechoOcorrencia.Descricao;

                        trecho.FotosOcorrencias = [];
                        if (trechoOcorrencia.OcorrenciaNavegadorFoto && trechoOcorrencia.OcorrenciaNavegadorFoto.length) {
                            trechoOcorrencia.OcorrenciaNavegadorFoto.forEach(foto => {
                                trecho.FotosOcorrencias.push({
                                    Foto: `data:image/png;base64,${foto.ImagemBase64}`,
                                    Descricao: foto.Identificador
                                });
                            });
                        }
                    }
                });
            }

        function toggleTodosAlarmesPacman() {
            scope.vm.tratamentoAlarme.ListaTrechos.forEach(trecho => trecho.checked = scope.vm.alarmePacmanTodos);
        }

        function toggleAlarmesPacman() {
            scope.vm.alarmePacmanTodos = scope.vm.tratamentoAlarme.ListaTrechos.length ===
                scope.vm.tratamentoAlarme.ListaTrechos.filter(x => x.checked).length;
        }

        function aplicarJustificativasAlarmePacman() {
            scope.vm.tratamentoAlarme.ListaTrechos.filter(x => x.checked).forEach(trecho => {
                trecho.JustificativaTrechoSelecionada = scope.vm.justificativaPacmansSelecionados;
                trecho.DescricaoJustObservacao = scope.vm.observacaoPacmansSelecionados;

                let campo = scope.vm.formTratarAlarmes.$$controls.find(campo =>
                    (campo.$name.includes('justificativaTrecho') || campo.$name.includes('observacaoTrecho')) &&
                    trecho.Codigo.toString() === campo.$$attr.codigoTrecho);

                campo.$viewChangeListeners.forEach((func) => func());
            });
        }

        function errorRequest(error) {
            scope.vm.hideLoading();
            scope.vm.hideLoadingFooter();
            console.error(error);
        }
    }
}
})();
