using AgroBase.Comum;
using AgroBase.Forms;
using AgroBase.Forms.Operacoes;
using AgroBase.Models.Modules;
using AgroBase.Models.Operacoes;
using AgroBase.Services;
using CefSharp.DevTools.Network;
using Emgu.CV.CvEnum;
using Newtonsoft.Json;
using OpenTK.Graphics.ES11;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
using static AgroBase.Models.Enuns;

namespace AgroBase.Models
{
    public class OperacaoModel
    {
        public OperacaoModel(ModoOperacao Modo, DispositivosService<MovimentacaoModel> Mov = null, DispositivosService<DirecionalModel> Dir = null, DispositivosService<AtuadorModel> Atu = null) 
        {
            this.Modo = Modo;
            
            this.DispMov = Mov;
            this.DispDir = Dir;
            this.DispAtu = Atu;

            if (Modo == ModoOperacao.MapaGPS)
            {
                this.OpMapaGPS.Controle = new OperacaoControleModel()
                {
                    PIDdirecional = new PIDModel(),
                    TiposControle = new List<OperacaoControleTipoModel>()
                    {
                        new OperacaoControleTipoModel()
                        {
                            Tipo = T_Code.Mov,
                            DelayEnvioComando = 500,
                            Comandos = new List<string>(),
                            UltimoComando = DateTime.Now
                        },
                        new OperacaoControleTipoModel()
                        {
                            Tipo = T_Code.Dir,
                            DelayEnvioComando = 1000,
                            Comandos = new List<string>(),
                            UltimoComando = DateTime.Now
                        },
                        new OperacaoControleTipoModel()
                        {
                            Tipo = T_Code.Atu,
                            DelayEnvioComando = 100,
                            Comandos = new List<string>(),
                            UltimoComando = DateTime.Now
                        },
                    },
                };
                this.OpMapaGPS.ControleAnterior = new OperacaoControleModel();

                this.OpMapaGPS.Sensoriamento.AtuacoesPorBico = new List<int>();
                if (DispAtu != null)
                {
                    for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
                    {
                        this.OpMapaGPS.Sensoriamento.AtuacoesPorBico.Add(0);
                    }
                }
            }

            
            if (!this.tmrLogs.Enabled)
            {
                this.tmrLogs.Tick -= TmrLogs_Tick;
                this.tmrLogs.Tick += TmrLogs_Tick;
                this.tmrLogs.Start();
            }
        }

        

        public ModoOperacao Modo { get; set; }
        public OperacaoMapaGPSModel OpMapaGPS { get; set; } = new OperacaoMapaGPSModel();
        public OperacaoManualModel OpManual { get; set; } = new OperacaoManualModel();
        public DispositivosService<SensoriamentoModel> DispSen { get; set; }
        public DispositivosService<MovimentacaoModel> DispMov { get; set; }
        public DispositivosService<DirecionalModel> DispDir { get; set; }
        public DispositivosService<AtuadorModel> DispAtu { get; set; }
        public MapasModel Mapa { get; set; } = new MapasModel();
        public OperacaoSensoriamentoModel Sensoriamento { get; set; }
        public Form frmOperacao { get; set; }
        private StatusOperacao _EtapaAtual;
        private StatusOperacao _EtapaAnteriorParada = StatusOperacao.Parado;
        public StatusOperacao StatusAtual 
        {
            get
            {
                StatusOperacao etapaAtual = _EtapaAtual;

                // Se a operação não estiver iniciada
                if (!Variaveis.OperacaoEmAndamento.Iniciado)
                {
                    // Etapa atual não é Finalizado, então a etapa é Parametrizando
                    if (_EtapaAtual != StatusOperacao.Concluido)
                    {
                        etapaAtual = StatusOperacao.Parametrizando;
                    }
                }
                // Operação em andamento
                else
                {
                    // Se a operacao atual for manual
                    if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.Manual)
                    {
                        etapaAtual = StatusOperacao.EmAndamento;
                    }
                    // Se o trajeto foi finalizado
                    else if (Variaveis.OperacaoEmAndamento.OpMapaGPS.Concluido)
                    {
                        etapaAtual = StatusOperacao.Concluido;
                    }
                    // Se a operação tiver algum item mandatório interrompido
                    else if (!Variaveis.OperacaoEmAndamento.OperacaoLiberada)
                    {
                        // Da primeira vez, salva a etapa atual anterior à parada para possível retomada
                        if (etapaAtual != StatusOperacao.Parado)
                        {
                            _EtapaAnteriorParada = etapaAtual;
                        }
                        etapaAtual = StatusOperacao.Parado;
                    }
                    // Se a etapa atual for parado, mas a operação foi liberada, retoma de onde parou
                    else if (etapaAtual == StatusOperacao.Parado && Variaveis.OperacaoEmAndamento.OperacaoLiberada)
                    {
                        Variaveis.OperacaoEmAndamento.TempoAguardando = DateTime.Now;
                        etapaAtual = StatusOperacao.Aguardando;
                    }
                    // Etapa atual é finalizada, então finaliza a operação
                    else if (_EtapaAtual == StatusOperacao.Concluido)
                    {
                        if (Variaveis.OperacaoEmAndamento.Iniciado)
                        {
                            Variaveis.OperacaoEmAndamento.FinalizarOperacao();
                        }
                    }
                    // Contagem regressiva para iniciar a operação
                    else if (Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) > DateTime.Now)
                    {
                        etapaAtual = StatusOperacao.Aguardando;
                    }
                    else if (_EtapaAnteriorParada != StatusOperacao.Parado)
                    {
                        etapaAtual = _EtapaAnteriorParada;
                        _EtapaAnteriorParada = StatusOperacao.Parado;
                    }
                    else
                    {
                        etapaAtual = StatusOperacao.EmAndamento;
                    }
                }


                _EtapaAtual = etapaAtual;

                //_EtapaAtual = StatusOperacao.EmAndamento;

                return _EtapaAtual;
            }
        }
        public bool ModulosConectados
        {
            get
            {
                ModulosMandatorios.ForEach(Modulo =>
                {
                    if (Modulo.Dispositivo == T_Code.Gps)
                    {
                        Modulo.Conectado = GPSService.PortaGPS != null && GPSService.PortaGPS.IsOpen;
                    }
                    else
                    {
                        Modulo.Conectado = Variaveis.DispositivosConectados.Any(x => x.Dispositivo == Modulo.Dispositivo && x._Porta.IsOpen);
                    }
                });

                bool _modulosConectados =
                (ModulosMandatorios.Where(x => x.Mandatorio).All(x => x.Conectado) && ModulosMandatorios.Any(x => x.Mandatorio)) ||
                (ModulosMandatorios.All(x => !x.Mandatorio) && ModulosMandatorios.Any(x => x.Conectado));


                return _modulosConectados;
            }
        }
        public bool OperacaoLiberada
        {
            get
            {
                bool _operacaoLiberada = ModulosConectados;
                if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraSolo && x.Mandatorio) && CamerasSolo.Count(x => x.Iniciada) < QuantidadeCamerasSolo) _operacaoLiberada = false;
                if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.CameraCaminho && x.Mandatorio) && (CameraCaminho == null || !CameraCaminho.Iniciada)) _operacaoLiberada = false;
                if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Mapa && x.Mandatorio) && !Mapa.mapaService.Carregado) _operacaoLiberada = false;
                if (ParametrosMandatorios.Any(x => x.Parametro == ParametrosOperacao.Joystick && x.Mandatorio && GeneralJoystick.JoystickConectado == null)) _operacaoLiberada = false;

                if (frmInstancial.frmPrincipal.chbDebugMode.Checked) _operacaoLiberada = true;

                return _operacaoLiberada;
            }
        }
        public string ErroOperacaoLiberada
        {
            get
            {
                string MensagemErro = "Para iniciar a operação " + Enum.GetName(typeof(ModoOperacao), Modo) +
                            ", é necessário que todos os módulos mandatórios estejam devidamente conectados ao equipamento, ou pelo menos um dos módulos:\r\n";
                ModulosMandatorios.ForEach(Modulo =>
                {
                    MensagemErro += Enum.GetName(typeof(T_Code), Modulo.Dispositivo) + ": ( " + (Modulo.Conectado ? "OK" : "  ") + " ) - Mandatório: " + (Modulo.Mandatorio ? "Sim" : "Não") + "\r\n";
                });
                return MensagemErro;
            }
        }
        public bool Iniciado { get; set; }
        public long TimestampInicio { get; set; }
        public long TimestampFim { get; set; }
        public TimeSpan Tempo 
        { 
            get
            {
                return TimeSpan.FromTicks(Variaveis.OperacaoEmAndamento.Iniciado ? ((Variaveis.OperacaoEmAndamento.TimestampFim > 0 ? Variaveis.OperacaoEmAndamento.TimestampFim : DateTime.Now.Ticks) - Variaveis.OperacaoEmAndamento.TimestampInicio) : 0);
            }
        }
        public DateTime TempoAguardando { get; set; }
        
        public List<OperacaoModulosMandatoriosModel> ModulosMandatorios { get; set; } = new List<OperacaoModulosMandatoriosModel>();
        public List<OperacaoParametrosMandatoriosModel> ParametrosMandatorios { get; set; } = new List<OperacaoParametrosMandatoriosModel>();
        public List<OperacaoSensoriamentoModel> Logs { get; set; } = new List<OperacaoSensoriamentoModel>();
        public List<GPSModel> GPSTrajetoria { get; set; } = new List<GPSModel>();
        public List<List<GPSModel>> GPSTrajetoriaRua { get; set; } = new List<List<GPSModel>>();
        public DirecaoCarroRua DirecaoCaminho
        {
            get
            {
                DirecaoCarroRua direcaoCaminho = Mapa.IdxRuaAtual % 2 == 0 ? DirecaoCarroRua.Ida : DirecaoCarroRua.Volta;
                return direcaoCaminho;
            }
        }
        public int QuantidadeCamerasSolo { get; set; } = 2;
        public List<CameraSoloModel> CamerasSolo { get; set; } = new List<CameraSoloModel>();
        public CameraCaminhoModel CameraCaminho { get; set; }
        public int TempoIniciarOperacao { get; set; } = 25;
        public string ID { get; set; }
        public Timer tmrLogs = new Timer() { Interval = 5000 };
        

        public static OperacaoModel CarregarParametrosOperacaoPadrao(ModoOperacao Modo)
        {
            var SenConectado = (DispositivosService<SensoriamentoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Sen);
            var MovConectado = (DispositivosService<MovimentacaoModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Mov);
            var DirConectado = (DispositivosService<DirecionalModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Dir);
            var AtuConectado = (DispositivosService<AtuadorModel>)Variaveis.DispositivosConectados.FirstOrDefault(x => x.Dispositivo == T_Code.Atu);

            Variaveis.OperacaoEmAndamento.tmrLogs.Stop();

            OperacaoModel OperacaoCarregar = new OperacaoModel(Modo)
            {
                Iniciado = false,
                TimestampInicio = 0,
                TimestampFim = 0,
                DispAtu = AtuConectado,
                DispDir = DirConectado,
                DispMov = MovConectado,
                DispSen = SenConectado, 
                Logs = new List<OperacaoSensoriamentoModel>(),
                Sensoriamento = new OperacaoSensoriamentoModel(),
            };
            

            switch (Modo)
            {
                case ModoOperacao.Manual:
                    OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpManual.frmOperacao.GetType());
                    OperacaoCarregar.OpManual.Controle = new OperacaoControleModel()
                    {
                        TiposControle = new List<OperacaoControleTipoModel>()
                        {
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Mov,
                                DelayEnvioComando = 10,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Dir,
                                DelayEnvioComando = 10,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                        },
                    };
                    OperacaoCarregar.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mov,
                            Mandatorio = false,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Dir,
                            Mandatorio = false,
                        },
                    };
                    OperacaoCarregar.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Joystick,
                            Mandatorio = false,
                        }
                    };
                    OperacaoCarregar.Sensoriamento.SonarFrontal = new SonarModel(FuncoesGlobais.FindControlRecursive<PictureBox>(OperacaoCarregar.frmOperacao, "picSonar"));
                    break;
                case ModoOperacao.MapaGPS:
                    OperacaoCarregar.frmOperacao = (Form)Activator.CreateInstance(Variaveis.OperacaoEmAndamento.OpMapaGPS.frmOperacao.GetType());
                    OperacaoCarregar.Logs = new List<OperacaoSensoriamentoModel>();
                    OperacaoCarregar.OpMapaGPS.ControleAnterior = new OperacaoControleModel();
                    OperacaoCarregar.OpMapaGPS.Controle = new OperacaoControleModel()
                    {
                        RPM_Max = 45,
                        RPM_Min = 15,
                        Angulo_Max = 30,
                        Angulo_Min = -30,
                        VelocidadeMP = 50,
                        TiposControle = new List<OperacaoControleTipoModel>()
                        {
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Mov,
                                DelayEnvioComando = 500,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Dir,
                                DelayEnvioComando = 1000,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                            new OperacaoControleTipoModel()
                            {
                                Tipo = T_Code.Atu,
                                DelayEnvioComando = 500,
                                Comandos = new List<string>(),
                                UltimoComando = DateTime.Now
                            },
                        },
                    };
                    OperacaoCarregar.ModulosMandatorios = new List<OperacaoModulosMandatoriosModel>()
                    {
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Mov,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Dir,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Atu,
                            Mandatorio = true,
                        },
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Gps, 
                            Mandatorio = true, 
                        }, 
                        new OperacaoModulosMandatoriosModel()
                        {
                            Dispositivo = T_Code.Sen, 
                            Mandatorio = false, 
                        }
                    };
                    OperacaoCarregar.ParametrosMandatorios = new List<OperacaoParametrosMandatoriosModel>()
                    {
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.CameraSolo, 
                            Mandatorio = true,
                        },
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.CameraCaminho, 
                            Mandatorio = true,
                        }, 
                        new OperacaoParametrosMandatoriosModel()
                        {
                            Parametro = ParametrosOperacao.Mapa, 
                            Mandatorio = true,
                        }
                    };
                    OperacaoCarregar.OpMapaGPS.Sensoriamento = new OperacaoMapaGPSSensoriamentoModel();
                    if (OperacaoCarregar.DispAtu != null)
                    {
                        for (int i = 0; i < OperacaoCarregar.DispAtu.Dados.QuantidadeBicos; i++)
                        {
                            OperacaoCarregar.OpMapaGPS.Sensoriamento.AtuacoesPorBico.Add(0);
                        }
                    }
                    break;
            }

            if (OperacaoCarregar.DispSen != null && OperacaoCarregar.DispSen.Dados.Conectado)
            {
                OperacaoCarregar.DispSen.Dados.Sinaleiros.ForEach(x => x.Comportamento = Variaveis.ComportamentoPorStatus(StatusOperacao.NaoIniciado));

                OperacaoCarregar.DispSen.Dados.Sinaleiros.First(x => x.ID == (Modo == ModoOperacao.Manual ? "LEDMN" : "LEDAT")).Comportamento.statusLED = StatusLED.Aceso;
                OperacaoCarregar.DispSen.Dados.Sinaleiros.First(x => x.ID == "LEDOP").Comportamento = Variaveis.ComportamentoPorStatus();


                OperacaoCarregar.DispSen.Dados.Sinaleiros.ForEach(x => OperacaoCarregar.DispSen.AdicionarMensagemFila(x.ProtocoloComando()));
            }
            

            return OperacaoCarregar;
        }

        public static void SalvarOperacaoPersonalizada(OperacaoModel Operacao)
        {
            if (Variaveis.OperacaoEmAndamento.Modo == ModoOperacao.MapaGPS)
            {
                Operacao.OpMapaGPS.frmOperacaoNome = Operacao.OpMapaGPS.frmOperacao.Name;
                Form frm = Operacao.OpMapaGPS.frmOperacao;

                Operacao.OpMapaGPS.frmOperacao = null;

                //File.WriteAllText("operacao" + Enum.GetName(typeof(ModoOperacao), Operacao.Modo) + ".opr", JsonConvert.SerializeObject(Operacao));

                Operacao.OpMapaGPS.frmOperacao = frm;
            }
            
        }

        public static OperacaoModel CarregarOperacaoPersonalizada(string nomeArquivo)
        {
            string modoOpStr = nomeArquivo.Split('\\')[nomeArquivo.Split('\\').Length - 1].Replace("operacao", "").Split('.')[0];
            ModoOperacao modo = (ModoOperacao)Enum.Parse(typeof(ModoOperacao), modoOpStr);
            return CarregarParametrosOperacaoPadrao(modo);
            
            OperacaoModel Operacao = new OperacaoModel(modo);
            if (!File.Exists(nomeArquivo))
            {
                Operacao = CarregarParametrosOperacaoPadrao(modo);
                SalvarOperacaoPersonalizada(Operacao);
            }

            var operacaoText = File.ReadAllText(nomeArquivo);
            Operacao = JsonConvert.DeserializeObject<OperacaoModel>(operacaoText);

            Type tipoDoForm = Type.GetType(Operacao.OpMapaGPS.frmOperacaoNome);
            if (tipoDoForm != null)
            {
                Operacao.OpMapaGPS.frmOperacao = (Form)Activator.CreateInstance(tipoDoForm);
            }

            return Operacao;
        }

        public void IniciarOperacao(OperacaoControleModel controle = null, bool DaIHM = true)
        {
            Iniciado = true;
            TimestampInicio = DateTime.Now.Ticks;
            TempoAguardando = DateTime.Now;
            TimestampFim = 0;
            Mapa.IdxRuaAtual = 0;
            if (DispMov != null)
            {
                DispMov.Dados.DistanciaPercorridaOperacao = 0;
                DispMov.Dados.TempoEmAtividade = 0;
            }
            if (DispDir != null)
            {
                DispDir.Dados.Motores.ForEach(x =>
                {
                    x.Referenciado = false;
                    x.Referenciando = false;
                });
            }
            Sensoriamento.DistanciaPercorrida = new List<double>();
            if (Modo == ModoOperacao.MapaGPS)
            {
                OpMapaGPS.Sensoriamento = new OperacaoMapaGPSSensoriamentoModel();
                OpMapaGPS.Logs = new List<OperacaoMapaGPSSensoriamentoModel>();
                if (DispAtu != null)
                {
                    DispAtu.Dados.BombaPressurizadora.BombaAtuada = false;
                    for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
                    {
                        OpMapaGPS.Sensoriamento.AtuacoesPorBico.Add(0);
                        DispAtu.Dados.BicosPulverizadores[i].Atuado = false;
                    }
                    DispAtu.Dados.VolumeVazaoML = 0;
                }
                OpMapaGPS.Controle.PIDdirecional = new PIDModel()
                {
                    LimiteSaida = OpMapaGPS.Controle.Angulo_Max,
                    SetPoint = 0,
                    Kp = 1.0,
                    Ki = 0.1,
                    Kd = 0.01,
                };
                if (controle != null)
                {
                    OpMapaGPS.Controle = controle;
                }
            }
            Logs = new List<OperacaoSensoriamentoModel>();
            GPSTrajetoria = new List<GPSModel>();
            ID = (new DateTime(TimestampInicio)).ToString("dd_MM_yyyy_HH_mm_ss");

            Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID + "/");

            GPSService.IniciarRecepcaoDados();

            //Controle = new OperacaoControleModel();
            //ControleAnterior = new OperacaoControleModel();
            

            //tmrParametrizacao.Stop();

            RealizarCalibracaoInicialAsync().ConfigureAwait(false);
        }
        
        public void FinalizarOperacao()
        {
            if (Modo == ModoOperacao.MapaGPS)
            {
                OpMapaGPS.Controle.Angulo = 0;
                OpMapaGPS.Controle.RPM = 0;
                OpMapaGPS.AtualizarDadosControle();
            }
            if (DispAtu.Dados.BombaPressurizadora.Inicializado)
            {
                DispAtu.Dados.BombaPressurizadora.BombaAtuada = false;
                string Protocolo = DispAtu.Dados.BombaPressurizadora.ProtocoloComando();
                DispAtu.AdicionarMensagemFila(Protocolo);
            }

            Iniciado = false;
            TimestampFim = DateTime.Now.Ticks;

            //tmrLogs.Stop();
            //tmrParametrizacao.Start();

            SalvarLog(true);

            GPSService.PararRecepcaoDados();

            AtualizarSinaleiroOperacao();
        }

        public async Task RealizarCalibracaoInicialAsync()
        {
            if (DispAtu != null)
            {
                // Ligar bomba
                if (DispAtu.Dados.BombaPressurizadora.Inicializado)
                {
                    DispAtu.Dados.BombaPressurizadora.BombaAtuada = true;
                    string Protocolo = DispAtu.Dados.BombaPressurizadora.ProtocoloComando();
                    DispAtu.AdicionarMensagemFila(Protocolo);
                }

                await Task.Delay(5000);

                // Testar os bicos
                for (int i = 0; i < DispAtu.Dados.QuantidadeBicos; i++)
                {
                    var Bico = DispAtu.Dados.BicosPulverizadores[i];
                    if (Bico.Inicializado)
                    {
                        Bico.Atuado = true;
                        DispAtu.AdicionarMensagemFila(Bico.ProtocoloComando());

                        await Task.Delay(1000);

                        Bico.Atuado = false;
                        DispAtu.AdicionarMensagemFila(Bico.ProtocoloComando());
                    }
                }

                await Task.Delay(1000);
            }

            // Referenciar o direcional
            if (DispDir != null)
            {
                foreach (var Motor in DispDir.Dados.Motores)
                {
                    DispDir.AdicionarMensagemFila(Motor.ProtocoloComando(Direcao.Parado, true));

                    while (Motor.Referenciando)
                    {
                        await Task.Delay(500);
                    }
                }
            }
        }

        public void SalvarLog(bool Fim)
        {
            if (!string.IsNullOrEmpty(ID))
            {
                Logs.Add(new OperacaoSensoriamentoModel()
                {
                    Momento = DateTime.Now,
                    BateriaConsumida = Sensoriamento.BateriaConsumida,
                    DistanciaDireita = Sensoriamento.DistanciaDireita,
                    DistanciaEsquerda = Sensoriamento.DistanciaEsquerda,
                    DistanciaPercorrida = new List<double>(Sensoriamento.DistanciaPercorrida),
                    PorcentagemBateria = Sensoriamento.PorcentagemBateria,
                    AnguloCarroBussola = Sensoriamento.AnguloCarroBussola
                });
                if (!Directory.Exists(Variaveis.CaminhoOperacoes + ID))
                {
                    Directory.CreateDirectory(Variaveis.CaminhoOperacoes + ID);
                }
                if (!File.Exists(Variaveis.CaminhoOperacoes + ID + "/logsGerais.json"))
                {
                    string jsonLog = JsonConvert.SerializeObject(Logs, Formatting.None);
                    File.WriteAllText(Variaveis.CaminhoOperacoes + ID + "/logsGerais.json", jsonLog.Substring(0, jsonLog.Length - 1));
                }
                else
                {
                    string jsonLog = JsonConvert.SerializeObject(Logs[Logs.Count - 1], Formatting.None);
                    File.AppendAllText(Variaveis.CaminhoOperacoes + ID + "/logsGerais.json", "," + jsonLog + (Fim ? "]" : ""));
                }


                
                File.WriteAllText(Variaveis.CaminhoOperacoes + ID + "/trajetoria.json", JsonConvert.SerializeObject(GPSTrajetoria, Formatting.None));
            }
        }

        private void TmrLogs_Tick(object sender, EventArgs e)
        {
            if (Iniciado)
            {
                SalvarLog(false);
            }

            AtualizarSinaleiroOperacao();
        }

        public void AtualizarSinaleiroOperacao()
        {
            if (DispSen != null && DispSen.Dados.Conectado)
            {
                DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDOP").Comportamento = Variaveis.ComportamentoPorStatus();
                DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDAT").Comportamento.statusLED = Modo == ModoOperacao.MapaGPS ? StatusLED.Aceso : StatusLED.Apagado;
                DispSen.Dados.Sinaleiros.FirstOrDefault(x => x.ID == "LEDMN").Comportamento.statusLED = Modo == ModoOperacao.Manual ? StatusLED.Aceso : StatusLED.Apagado;
                
                DispSen.Dados.Sinaleiros.ForEach(x => DispSen.AdicionarMensagemFila(x.ProtocoloComando()));
            }
        }

        public void AbrirForm()
        {
            if (Variaveis.OperacaoEmAndamento.OperacaoLiberada)
            {
                frmOperacao = (Form)Activator.CreateInstance((
                    Modo == ModoOperacao.Manual ? Variaveis.OperacaoEmAndamento.OpManual.frmOperacao :
                    Modo == ModoOperacao.MapaGPS ? Variaveis.OperacaoEmAndamento.OpMapaGPS.frmOperacao :
                    new Form()
                ).GetType());
                Variaveis.OperacaoEmAndamento.Sensoriamento.SonarFrontal = new SonarModel(FuncoesGlobais.FindControlRecursive<PictureBox>(frmOperacao, "picSonar"));
                frmOperacao.Show();
            }
            else
            {
                MessageBox.Show(Variaveis.OperacaoEmAndamento.ErroOperacaoLiberada, "Conexão de módulos pendentes", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }
    
        public string TextoFormOperacao(string ModoNome)
        {
            var statusAtual = Variaveis.OperacaoEmAndamento.StatusAtual;

            if (statusAtual == StatusOperacao.Parametrizando)
            {
                return "Operação " + ModoNome + " - Parametrização";
            }
            else if (statusAtual == StatusOperacao.Aguardando)
            {
                return "Operação " + ModoNome + " - Iniciando em " + (Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds.ToString("0") + " segundo" + ((Variaveis.OperacaoEmAndamento.TempoAguardando.AddSeconds(Variaveis.OperacaoEmAndamento.TempoIniciarOperacao) - DateTime.Now).TotalSeconds < 1 ? "" : "s") + "...";
            }
            else if (statusAtual == StatusOperacao.Concluido)
            {
                return "Operação " + ModoNome + " - Concluída";
            }
            else if (statusAtual == StatusOperacao.EmAndamento)
            {
                return "Operação " + ModoNome + " - Em andamento";
            }
            else
            {
                return "Operação " + ModoNome;
            }
        }
    
    }

    public class OperacaoSensoriamentoModel
    {
        public DateTime Momento { get; set; }
        public double VelocidadeMedia
        {
            get
            {
                return Variaveis.OperacaoEmAndamento.DispMov.Dados.Motores.Average(x => x.VelocidadeInstantanea);
            }
        }
        public double PorcentagemBateria { get; set; } = 0;
        public double BateriaConsumida { get; set; } = 0;
        public List<double> DistanciaPercorrida { get; set; } = new List<double>();
        public double DistanciaEsquerda { get; set; } = 0;
        public double DistanciaDireita { get; set; } = 0;
        public double AnguloCarroGPS
        {
            get
            {
                int PontosConsiderarAngulo = 2;
                double Angulo = 0;

                int Indice = Variaveis.OperacaoEmAndamento.Mapa.mapaService.MapaUrl != "" ? Variaveis.OperacaoEmAndamento.Mapa.IdxRuaAtual : 0;

                try
                {
                    double somaAngulo = 0;
                    var Pontos = !Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua.Any() || Indice >= Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua.Count() ? new List<GPSModel>() :
                        Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua[Indice].Count > PontosConsiderarAngulo ?
                        Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua[Indice].OrderByDescending(x => x.DataHora).Take(PontosConsiderarAngulo).ToList() :
                        Variaveis.OperacaoEmAndamento.GPSTrajetoriaRua[Indice].OrderByDescending(x => x.DataHora).ToList();
                    Pontos = Pontos.OrderBy(x => x.DataHora).ToList();
                    for (int i = 0; i < Pontos.Count() - 1; i++)
                    {
                        somaAngulo += GPSService.CalcularOrientacao(Pontos[i + 1], Pontos[i]);
                    }
                    double mediaAngulo = somaAngulo / (Pontos.Count() - 1);

                    Angulo = (!(mediaAngulo >= 0 || mediaAngulo <= 0)) ? 0 : mediaAngulo;
                }
                catch
                {
                    Angulo = 0;
                }

                return Angulo;
            }
        }
        public double AnguloCarroBussola { get; set; } = 0;
        public double AnguloCarro
        {
            get
            {
                if (Variaveis.OperacaoEmAndamento.DispSen._Porta.IsOpen && Variaveis.OperacaoEmAndamento.DispSen.Dados.Sensores.Any(x => x.Componente == S_Code.sMAG && x.Inicializado))
                {
                    return AnguloCarroBussola;
                }
                else
                {
                    return AnguloCarroGPS;
                }
            }
        }
        public SonarModel SonarFrontal { get; set; }

    }

    public class OperacaoControleModel
    {
        public int RPM_Max { get; set; } = 45;
        public int RPM_Min { get; set; } = 15;
        public double Angulo_Max { get; set; } = 30;
        public double Angulo_Min { get; set; } = -30;
        public double VelocidadeMP { get; set; } = 50;

        public double Angulo { get; set; } = 0;
        public int RPM { get; set; } = 0;
        public Direcao Direcao { get; set; } = Direcao.Parado;
        public List<AtuadorBicoModel> BicosAtuados { get; set; } = new List<AtuadorBicoModel>();

        public List<OperacaoControleTipoModel> TiposControle { get; set; }
        public PIDModel PIDdirecional { get; set; } = new PIDModel();
    }

    public class OperacaoControleTipoModel
    {
        public T_Code Tipo { get; set; }
        public int DelayEnvioComando { get; set; }
        public DateTime UltimoComando { get; set; }
        public List<string> Comandos { get; set; }
    }

    public class OperacaoModulosMandatoriosModel
    {
        public T_Code Dispositivo { get; set; }
        public bool Mandatorio { get; set; }
        public bool Utilizar { get; set; }
        public bool Conectado { get; set; }
    }

    public class OperacaoParametrosMandatoriosModel
    {
        public ParametrosOperacao Parametro { get; set; }
        public bool Mandatorio { get; set; }
        public bool Utilizar { get; set; }
        public bool Pronto { get; set; }
    }

    

    

}