(function () {
    'use strict';

    angular
        .module('contestacaoApp')
        .directive('ferramentaCamadas', ferramentaCamadas);

    ferramentaCamadas.$inject = ['__env', 'infowindowTemplates', 'contestacaoServiceFactory', 'utilsFactory', '$location', 'mapsSingletonService'];

    /* @ngInject */
    function ferramentaCamadas(__env, infowindowTemplates, contestacaoServiceFactory, utilsFactory, $location, mapsSingletonService) {
        return {
            restrict: 'E',
            replace: true,
            require: 'ngModel',
            templateUrl: __env.appPath + 'scripts/components/tools/camadas/ferramenta-camadas.directive.html',
            link: link,
            scope: false
        };

        function link(scope, element, attrs, ngModel) {
            let _urlParams = $location.$$search;

            //exports
            angular.extend(scope.vm, {
                carregarRotasPlanejadas: carregarRotasPlanejadas,
                toggleHistoricoVeiculo: toggleHistoricoVeiculo,
                toggleRotaPlanejada: toggleRotaPlanejada,
                toggleTodasRotaPlanejadas: toggleTodasRotaPlanejadas,
                toggleTodasRotasCompletas: toggleTodasRotasCompletas,
                setColorRotasCompletas: setColorRotasCompletas,
                setColorRotaPlanejada: setColorRotaPlanejada,
                setColorHistorico: setColorHistorico,
                showAll: showAll,
                hideAll: hideAll,
                toggleHistoricoRotaCompletaVeiculo: toggleHistoricoRotaCompletaVeiculo
            });

            if (scope.vm.camadas) {
                listarHistoricos(scope.vm.camadas.Veiculos);
                plotarSetor(scope.vm.camadas.Setor);
            }

            ngModel.$render = () => {
                if (ngModel.$modelValue) {
                    listarHistoricos(ngModel.$modelValue.Veiculos);
                    plotarSetor(ngModel.$modelValue.Setor);
                }
            };

            function carregarRotasPlanejadas() {
                scope.vm.configCamadas.rotasPlan.carregando = false;

                if (scope.vm.camadas.Planejado) {
                    scope.vm.camadas.Planejado.forEach(rota => {
                        let obj = {
                            descricao: `Rota ${rota.Descricao}`,
                            quantidade: rota.Pacmans.length,
                            distancia: rota.Distancia,
                            codigo: rota.Codigo,
                            cor: rota.CorSetorRota.Cor.CorHtml,
                            codigoGrupo: rota.Controle,
                            vigencia: rota.Ativo === 'F' ? utilsFactory.formatDate(new Date(rota.DataHoraUltDesativacao),
                                'dd/MM/yyyy hh:mm') : null
                        };

                        plotarRotaPlanejada(rota, obj.cor);

                        rota.checked = true;
                        toggleRotaPlanejada(rota, true);
                    });
                }

                carregarRotaCompletasPorVeiculo();
            }

            function listarHistoricos(veiculos) {
                if (veiculos) {
                    veiculos.forEach(veiculo => {
                        veiculo.HistoricoColetas.forEach(viagem => {
                            const pontos = [];
                            const infowindows = [];

                            viagem.ListaHistorico.forEach(x => {
                                pontos.push([x.Latitude / 1000000, x.Longitude / 1000000]);
                                infowindows.push(infowindowTemplates.montarInfoWindowTrajeto(x.InfoWindow));
                            });

                            const options = new InlogMaps.PolylineOptions(pontos);
                            options.zIndex = 5;
                            options.color = veiculo.CorVeiculo.CorHtml;
                            options.infowindows = infowindows;
                            options.style = InlogMaps.PolylineType.Arrow;
                            options.navigateOptions = new InlogMaps.NavigationOptions('#000000', 10);
                            options.object = { codigo: veiculo.CodigoVeiculo };

                            mapsSingletonService.getMap().drawPolylineWithNavigation(`historico_${veiculo.CodigoVeiculo}`, options);

                            veiculo.checked = true;
                            toggleHistoricoVeiculo(veiculo);
                        });
                    });
                }
            }

            function plotarSetor(setor) {
                setor.Areas.forEach((area) => {
                    const path = area.Coordenadas.map(x => [x.Latitude / 1000000, x.Longitude / 1000000]);
                    const options = new InlogMaps.PolygonOptions(path, 1, true);
                    options.fillColor = '#000';
                    options.fillOpacity = 0.3;
                    options.object = { codigo: scope.vm.camadas.Setor.Codigo };
                    mapsSingletonService.getMap().drawPolygon('setor', options);
                });

                mapsSingletonService.getMap().fitBoundsPolygons('setor');
            }

            function plotarRotaPlanejada(rota, cor) {
                let pontos = [];
                rota.SetorRotaTrecho.forEach(trecho => {
                    trecho.SetorRotaTrechoPonto.sort((a, b) => (a.Sequencia > b.Sequencia) ? 1 :
                        ((b.Sequencia > a.Sequencia) ? -1 : 0));

                    pontos = pontos.concat(trecho.SetorRotaTrechoPonto.map(value =>
                        [value.Latitude / 1000000, value.Longitude / 1000000]));
                });

                const options = new InlogMaps.PolylineOptions(pontos);
                options.color = cor;
                options.style = InlogMaps.PolylineType.Arrow;
                options.object = { codigo: rota.Codigo };
                options.zIndex = 4;
                mapsSingletonService.getMap().drawPolyline('planejado', options);
            }

            function carregarRotaCompletasPorVeiculo() {
                if (scope.vm.camadas.Completas) {
                    scope.vm.rotasCompletas = [];

                    scope.vm.camadas.Completas.forEach(rotaCompleta => {
                        let obj = {
                            descricao: `Veículo ${rotaCompleta.Veiculo.Identificador}`,
                            codigo: rotaCompleta.Codigo,
                            codigoGrupo: rotaCompleta.CodigoSetor,
                            cor: rotaCompleta.CorSetorRealizado.Cor.CorHtml,
                            checked: true
                        };

                        scope.vm.rotasCompletas.push(obj);
                        plotarHistorico(rotaCompleta, rotaCompleta.CorSetorRealizado.Cor.CorHtml);
                        toggleRotasCompletas(obj, true);
                    });
                }
            }

            function plotarHistorico(historico, cor) {
                let lista = historico.RastreamentoHistorico;
                if (lista.length > 0) {
                    const pontos = [];
                    const infowindows = [];

                    lista.forEach(x => {
                        pontos.push([x.Latitude / 1000000, x.Longitude / 1000000]);
                        infowindows.push(infowindowTemplates.montarInfoWindowTrajeto(x.InfoWindow));
                    });

                    const options = new InlogMaps.PolylineOptions(pontos);
                    options.color = cor;
                    options.infowindows = infowindows;
                    options.navigateOptions = new InlogMaps.NavigationOptions('#000000', 10);
                    options.style = InlogMaps.PolylineType.Arrow;
                    options.object = { codigo: historico.Codigo };
                    options.zIndex = 3;

                    mapsSingletonService.getMap().drawPolylineWithNavigation('historicoRotaCompleta', options);
                }
            }

            function toggleHistoricoVeiculo(veiculo) {
                mapsSingletonService.getMap().togglePolylines(veiculo.checked, `historico_${veiculo.CodigoVeiculo}`);

                if (!veiculo.checked) {
                    mapsSingletonService.getMap().removePolylineHighlight();
                }
            }

            function toggleHistoricoRotaCompletaVeiculo(veiculo) {
                toggleRotasCompletas(veiculo, true);

                if (!veiculo.checked) {
                    mapsSingletonService.getMap().removePolylineHighlight();
                }
            }

            function toggleTodasRotaPlanejadas() {
                (scope.vm.camadas.Planejado || []).forEach(rota => {
                    rota.checked = scope.vm.configCamadas.rotasPlan.toggleAll;
                    toggleRotaPlanejada(rota, false);
                });
            }

            function toggleTodasRotasCompletas() {
                (scope.vm.rotasCompletas || []).forEach(rota => {
                    rota.checked = scope.vm.configCamadas.rotasCompletas.toggleAll;
                    toggleRotasCompletas(rota, false);
                });

                if (!scope.vm.configCamadas.rotasCompletas.toggleAll) {
                    mapsSingletonService.getMap().removePolylineHighlight();
                }
            }

            function toggleRotaPlanejada(rota, validaTodas) {
                mapsSingletonService.getMap().togglePolylines(rota.checked, 'planejado',
                    (data) => data.codigo === rota.Codigo);

                if (validaTodas) {
                    scope.vm.configCamadas.rotasPlan.toggleAll = scope.vm.camadas.Planejado.every(x => x.checked);
                }
            }

            function toggleRotasCompletas(rota, validaTodas) {
                mapsSingletonService.getMap().togglePolylines(rota.checked, 'historicoRotaCompleta',
                    (data) => data.codigo === rota.codigo);

                if (validaTodas) {
                    scope.vm.configCamadas.rotasCompletas.toggleAll = scope.vm.rotasCompletas.every(x => x.checked);
                }
            }

            function setColorHistorico(veiculo, color) {
                setColorPolyline(`historico_${veiculo.CodigoVeiculo}`, color,
                    (data) => data.codigo === veiculo.CodigoVeiculo);
            }

            function setColorRotaPlanejada(rota, color) {
                setColorPolyline('planejado', color, (data) => data.codigo === rota.Codigo);
            }

            function setColorRotasCompletas(veiculo, color) {
                setColorPolyline('historicoRotaCompleta', color,
                    (data) => data.codigo === veiculo.codigo);
            }

            function setColorPolyline(type, color, condition) {
                const options = new InlogMaps.PolylineOptions();
                options.color = color;
                options.style = InlogMaps.PolylineType.Arrow;
                mapsSingletonService.getMap().alterPolylineOptions(type, options, condition);
            }

            function showAll() {
                scope.vm.camadas.Veiculos.forEach(veiculo => {
                    veiculo.checked = true;
                    mapsSingletonService.getMap().togglePolylines(veiculo.checked, `historico_${veiculo.CodigoVeiculo}`);
                });
            }

            function hideAll() {
                scope.vm.camadas.Veiculos.forEach(veiculo => {
                    veiculo.checked = false;

                    const mapa = mapsSingletonService.getMap();
                    mapa.togglePolylines(veiculo.checked, `historico_${veiculo.CodigoVeiculo}`);
                    mapa.closePopup('historico');
                    mapa.removePolylineHighlight();
                });

                scope.vm.configCamadas.rotasPlan.toggleAll = false;
                scope.vm.configCamadas.rotasCompletas.toggleAll = false;
                toggleTodasRotaPlanejadas();
                toggleTodasRotasCompletas();
            }
        }
    }
})();
