using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using static AgroBase.Models.Enums;

namespace AgroBase.Models.Operadores
{
    public class VisualWorkerModel
    {
        public bool Iniciado { get; set; }
        public DateTime IniciadoEm { get; set; }
        public bool Pronto { get; set; }
        public DateTime ProntoEm { get; set; }
        public DateTime UltimaMensagem { get; set; }
        public Dictionary<TipoFrameCamera, OAKCameraFrameModel> CameraFrames { get; set; } = new Dictionary<TipoFrameCamera, OAKCameraFrameModel>();
        public VisualWorkerMessageAnaliseModel Analises { get; set; } = new VisualWorkerMessageAnaliseModel();
        public VisualWorkerMessageIMUModel Imu { get; set; } = new VisualWorkerMessageIMUModel();
        public StatusModulo Status { get; set; }
        public VisualWorkerResumoModel Resumo { get; set; }

        public VisualWorkerModel Clone()
        {
            return new VisualWorkerModel()
            {
                Iniciado = Iniciado,
                IniciadoEm = IniciadoEm,
                Pronto = Pronto,
                ProntoEm = ProntoEm,
                CameraFrames = new Dictionary<TipoFrameCamera, OAKCameraFrameModel>(CameraFrames ?? new Dictionary<TipoFrameCamera, OAKCameraFrameModel>()),
                Analises = Analises?.Clone(),
                Imu = Imu?.Clone(), 
                UltimaMensagem = UltimaMensagem,
                Status = Status,
                Resumo = Resumo?.Clone()
            };
        }

        public void ReiniciarEstado()
        {
            Iniciado = false;
            IniciadoEm = DateTime.MinValue;
            Pronto = false;
            ProntoEm = DateTime.MinValue;
            CameraFrames = new Dictionary<TipoFrameCamera, OAKCameraFrameModel>();
            Analises = new VisualWorkerMessageAnaliseModel();
            Imu = new VisualWorkerMessageIMUModel();
            Resumo = new VisualWorkerResumoModel();
            Status = StatusModulo.Desconectado;
        }
    }

    public class VisualWorkerResumoModel
    {
        public StatusCarroMapa StatusCarro { get; set; }
        public double ErroLateral { get; set; }
        public double ErroAngular { get; set; }

        public bool ObstaculoDetectado { get; set; } = false;
        public bool DeveParar { get; set; } = false;
        public bool EnviarComandoParada { get; set; } = false;
        public bool EnviarComandoRetomada { get; set; } = false;
        private bool _comandoParadaEnviado { get; set; } = false;


        public void AtualizarStatusBloqueio(bool consideraEmMovimento)
        {
            var Sonar = Variaveis.OperacaoEmAndamento.Sensoriamento.OperadorVisual;
            ObstaculoDetectado = (Sonar?.Analises?.matriz_confianca?.block?.decision?.parar ?? false);
            StatusCarro = Sonar?.Analises?.segmentacao?.status_corredor ?? StatusCarroMapa.Indefinido;
            ErroLateral = Sonar?.Analises?.segmentacao?.erro_lateral_pct ?? 0;
            ErroAngular = Sonar?.Analises?.segmentacao?.erro_angular ?? 0;

            if (!(Variaveis.OperacaoEmAndamento.Parametros?.Controle?.OakParadaPorObstaculo ?? false))
            {
                _comandoParadaEnviado = false;
                DeveParar = false;
                EnviarComandoParada = false;
                EnviarComandoRetomada = false;
            }
            else
            {
                List<Direcao> _direcoesInterromperMovimento = new List<Direcao> { Direcao.Frente }; //, Direcao.Tras
                Direcao _ultimaDirecaoControle = Variaveis.OperacaoEmAndamento.Controle?.TiposControle?.FirstOrDefault(x => x?.Tipo == T_Code.Mov)?.UltimaDirecao ?? Direcao.Parado;
                bool _carroEmMovimento = _direcoesInterromperMovimento.Contains(_ultimaDirecaoControle);
                bool emMovimento = consideraEmMovimento ? _carroEmMovimento : true;
                DeveParar = Sonar?.Status == StatusModulo.Operante && ObstaculoDetectado;
                EnviarComandoParada = DeveParar && emMovimento;
                if (EnviarComandoParada)
                {
                    _comandoParadaEnviado = true;
                }
                EnviarComandoRetomada = !ObstaculoDetectado && _comandoParadaEnviado;
                if (EnviarComandoRetomada)
                {
                    _comandoParadaEnviado = false;
                }
            }
        }

        public VisualWorkerResumoModel Clone()
        {
            return new VisualWorkerResumoModel()
            {
                StatusCarro = StatusCarro,
                ErroLateral = ErroLateral,
                ErroAngular = ErroAngular,
                ObstaculoDetectado = ObstaculoDetectado,
                DeveParar = DeveParar, 
                EnviarComandoParada = EnviarComandoParada,
                EnviarComandoRetomada = EnviarComandoRetomada,
                _comandoParadaEnviado = _comandoParadaEnviado,
            };
        }

        public VisualWorkerResumoModel UpdateClone()
        {
            AtualizarStatusBloqueio(false);
            return Clone();
        }
    }

    public class VisualWorkerDadosModel
    {
        public bool DesvioNecessario { get; set; }
        public Enums.Direcao DirecaoDesvio { get; set; }
        public Obstaculo ObstaculoCritico { get; set; }
        public List<Obstaculo> Obstaculos { get; set; }

        public VisualWorkerDadosModel Clone()
        {
            return new VisualWorkerDadosModel()
            {
                DesvioNecessario = DesvioNecessario,
                DirecaoDesvio = DirecaoDesvio,
                ObstaculoCritico = ObstaculoCritico?.Clone(),
                Obstaculos = new List<Obstaculo>(Obstaculos ?? new List<Obstaculo>()),
            };
        }
    }

    
    public class VisualWorkerMessageResponseModel
    {
        public VisualWorkerCommandType cmd { get; set; }
        public VisualWorkerMessageResponseSaveFramesModel save_frames { get; set; }
        
        public VisualWorkerMessageResponseModel Clone()
        {
            return new VisualWorkerMessageResponseModel()
            {
                cmd = cmd, 
                save_frames = save_frames.Clone()
            };
        }
    }

    public class VisualWorkerMessageResponseSaveFramesModel
    {
        public long timestamp { get; set; }
        public List<string> frames { get; set; }

        private bool _newData = false;
        public bool newData
        {
            get
            {
                if (_newData)
                {
                    _newData = false;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            set
            {
                _newData = value;
            }
        }

        public VisualWorkerMessageResponseSaveFramesModel Clone()
        {
            return new VisualWorkerMessageResponseSaveFramesModel()
            {
                timestamp = timestamp, 
                frames = new List<string>(frames),
                newData = true
            };
        }
    }

    public class VisualWorkerMessageIMUModel
    {
        public long timestamp { get; set; }
        public double roll { get; set; }
        public double pitch { get; set; }
        public double yaw { get; set; }
        public double yaw_fixed { get; set; }

        public VisualWorkerMessageIMUModel Clone()
        {
            return new VisualWorkerMessageIMUModel()
            {
                timestamp = timestamp, 
                roll = roll,
                pitch = pitch,
                yaw = yaw,
            };
        }
    }
    
    public class VisualWorkerMessageSetupModel
    {
        public long timestamp { get; set; }
        public bool status { get; set; }

        private bool _newData = false;
        public bool newData
        {
            get
            {
                if (_newData)
                {
                    _newData = false;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            set
            {
                _newData = value;
            }
        }
        public VisualWorkerMessageSetupModel Clone()
        {
            return new VisualWorkerMessageSetupModel()
            {
                timestamp = timestamp,
                status = status,
                newData = true
            };
        }
    }

    public class VisualWorkerMessageAnaliseModel
    {
        public DateTime timestamp { get; set; }
        //public List<VisualWorkerMessageAnaliseBBoxModel> anomalias { get; set; }
        //public List<VisualWorkerMessageAnaliseBBoxModel> sombras { get; set; }
        //public VisualWorkerMessageAnaliseSoloModel solo { get; set; }
        //public List<VisualWorkerMessageRadar2DPerfilModel> corredor_prof { get; set; }
        //public List<VisualWorkerMessageRadar2DPerfilModel> corredor_seg { get; set; }
        public VisualWorkerMessageSegmentacaoSemanticaModel segmentacao { get; set; }
        public VisualWorkerMessageMatrizConfiancaModel matriz_confianca { get; set; }
        public List<VisualWorkerMessageDeteccaoModel> deteccao { get; set; }

        public VisualWorkerMessageAnaliseModel Clone()
        {
            return new VisualWorkerMessageAnaliseModel()
            {
                timestamp = timestamp, 
                //anomalias = new List<VisualWorkerMessageAnaliseBBoxModel>(anomalias ?? new List<VisualWorkerMessageAnaliseBBoxModel>()), 
                //sombras = new List<VisualWorkerMessageAnaliseBBoxModel>(sombras ?? new List<VisualWorkerMessageAnaliseBBoxModel>()), 
                //solo = solo?.Clone(),
                //corredor_prof = new List<VisualWorkerMessageRadar2DPerfilModel>(corredor_prof ?? new List<VisualWorkerMessageRadar2DPerfilModel>()),
                //corredor_seg = new List<VisualWorkerMessageRadar2DPerfilModel>(corredor_seg ?? new List<VisualWorkerMessageRadar2DPerfilModel>()),
                segmentacao = segmentacao?.Clone() ?? new VisualWorkerMessageSegmentacaoSemanticaModel(),
                matriz_confianca = matriz_confianca?.Clone() ?? new VisualWorkerMessageMatrizConfiancaModel(),
                deteccao = deteccao?.Select(x => x.Clone()).ToList() ?? new List<VisualWorkerMessageDeteccaoModel>()
            };
        }

        public Bitmap PlotarAnalise(OAKCameraFrameModel frame)
        {
            return null;
            /*Bitmap img = frame?.image();
            if (img == null) return null;

            using (Graphics g = Graphics.FromImage(img))
            {
                Pen penObstaculo = new Pen(Color.Red, 2);
                Pen penErosao = new Pen(Color.Blue, 2);
                Pen penLombada = new Pen(Color.Orange, 2);
                Pen penFaixaSolo = new Pen(Color.Black, 2);
                Pen penGrafico = new Pen(Color.DarkGreen, 2);

                Font font = new Font("Arial", 8);
                Brush brush = Brushes.Black;

                // 🔸 Definir brushes semi-transparentes para preenchimento
                Brush brushObstaculo = new SolidBrush(Color.FromArgb(60, Color.Red));
                Brush brushErosao = new SolidBrush(Color.FromArgb(60, Color.Blue));
                Brush brushLombada = new SolidBrush(Color.FromArgb(60, Color.Orange));

                int imgWidth = img.Width;
                int imgHeight = img.Height;

                // 🔸 Desenhar Bounding Boxes (Anomalias + Solo)
                List<VisualWorkerMessageAnaliseBBoxModel> bboxes = new List<VisualWorkerMessageAnaliseBBoxModel>();
                if (anomalias != null) bboxes.AddRange(anomalias);
                //if (solo?.bbox_list != null) bboxes.AddRange(solo.bbox_list);

                foreach (var bbox in bboxes)
                {
                    Pen pen = penObstaculo;
                    Brush fill = brushObstaculo;

                    if (bbox.tipo == "erosao")
                    {
                        pen = penErosao;
                        fill = brushErosao;
                    }
                    if (bbox.tipo == "lombada")
                    {
                        pen = penLombada;
                        fill = brushLombada;
                    }

                    int x = (int)(bbox.bbox[0] * imgWidth);
                    int y = (int)(bbox.bbox[1] * imgHeight);
                    int w = (int)(bbox.bbox[2] * imgWidth);
                    int h = (int)(bbox.bbox[3] * imgHeight);
                    var rect = new Rectangle(x, y, w, h);

                    // 🔸 Preencher com opacidade
                    g.FillRectangle(fill, rect);

                    // 🔸 Contorno
                    g.DrawRectangle(pen, rect);

                    // 🔸 Label
                    string label = $"{bbox.tipo} {bbox.distancia_m}m Δ{bbox.variacao}mm";
                    g.DrawString(label, font, brush, rect.X, rect.Y - 12);
                }

                // 🔸 Linha da faixa do solo
                if (solo != null)
                {
                    int yInicio = imgHeight - (int)(solo.percent_y * imgHeight);
                    g.DrawLine(penFaixaSolo, 0, yInicio, imgWidth, yInicio);
                }

                // 🔸 Gráfico do perfil de solo
                if (solo?.perfil != null && solo.perfil.Count > 1)
                {
                    var perfil = solo.perfil;
                    int setores = solo.perfil.Count;
                    int yInicio = imgHeight - (int)(solo.percent_y * imgHeight);
                    int alturaRegiao = imgHeight / solo.perfil.Count;

                    double maxZ = perfil.Max();
                    double minZ = perfil.Min();
                    if (maxZ == minZ) maxZ += 1; // evita divisão por zero

                    for (int i = 0; i < perfil.Count - 1; i++)
                    {
                        float x1 = (float)(i * imgWidth / setores + imgWidth / (2.0 * setores));
                        float x2 = (float)((i + 1) * imgWidth / setores + imgWidth / (2.0 * setores));

                        float y1 = (float)(yInicio + alturaRegiao - ((perfil[i] - minZ) / (maxZ - minZ)) * alturaRegiao);
                        float y2 = (float)(yInicio + alturaRegiao - ((perfil[i + 1] - minZ) / (maxZ - minZ)) * alturaRegiao);

                        g.DrawLine(penGrafico, x1, y1, x2, y2);
                        g.FillEllipse(Brushes.DarkGreen, x1 - 3, y1 - 3, 6, 6);
                    }

                    // Desenha o último ponto
                    float xLast = (float)((perfil.Count - 1) * imgWidth / setores + imgWidth / (2.0 * setores));
                    float yLast = (float)(yInicio + alturaRegiao - ((perfil.Last() - minZ) / (maxZ - minZ)) * alturaRegiao);
                    g.FillEllipse(Brushes.DarkGreen, xLast - 3, yLast - 3, 6, 6);
                }
            }

            return img;*/
        }

    }

    public class VisualWorkerMessageAnaliseSoloModel
    {
        public List<double> perfil { get; set; }
        public double percent_y { get; set; }
        public double inclinacao { get; set; }
        //public List<VisualWorkerMessageAnaliseBBoxModel> bbox_list { get; set; }
        //public int y_inicio { get; set; }
        //public int altura_regiao { get; set; }
        //public int n_setores { get; set; }

        public VisualWorkerMessageAnaliseSoloModel Clone()
        {
            return new VisualWorkerMessageAnaliseSoloModel()
            {
                perfil = new List<double>(perfil),
                percent_y = percent_y,
                inclinacao = inclinacao, 
                //bbox_list = new List<VisualWorkerMessageAnaliseBBoxModel>(bbox_list), 
                //y_inicio = y_inicio,
                //altura_regiao = altura_regiao,
                //n_setores = n_setores,
            };
        }
    }

    public class VisualWorkerMessageAnaliseBBoxModel
    {
        public string tipo { get; set; }
        public List<double> bbox { get; set; } // [x, y, w, h]
        public List<double> centro_percentual { get; set; } // [x%, y%]
        public double? distancia_m { get; set; }
        public double? largura_m { get; set; }
        public double? altura_m { get; set; }
        public List<double> profundidades { get; set; } // [z1, z2] ou null
        public double? variacao { get; set; } // delta Z ou null
    }

    public class VisualWorkerMessageRadar2DModel
    {
        public OAKCameraFrameModel frame { get; set; }
        public VisualWorkerMessageRadar2DAnaliseModel analise { get; set; }

        private bool _newData = false;
        public bool newData
        {
            get
            {
                if (_newData)
                {
                    _newData = false;
                    return true;
                }
                else
                {
                    return false;
                }
            }
            set
            {
                _newData = value;
            }
        }
        public VisualWorkerMessageRadar2DModel Clone()
        {
            return new VisualWorkerMessageRadar2DModel()
            {
                frame = frame.Clone(), 
                analise = analise.Clone(), 
                newData = true
            };
        }

        public Bitmap PlotarAnalsie(Bitmap img)
        {
            /*try
            {
                using (Graphics g = Graphics.FromImage(img))
                {
                    var grid = analise.grid_info;

                    double cellSize = grid.cell_size;
                    double escala = grid.escala;
                    int imgSize = (int)grid.img_size;
                    int centerX = (int)grid.center_x;
                    int centerY = (int)grid.center_y;
                    int gridX = (int)(2 * grid.distancia_max / cellSize);
                    int gridZ = (int)(grid.distancia_max / cellSize);

                    foreach (var bbox in analise.bboxes_sombra)
                    {
                        int xGrid = bbox.bbox[0];
                        int zGrid = bbox.bbox[1];
                        int wGrid = bbox.bbox[2];
                        int hGrid = bbox.bbox[3];

                        // 🔸 Converte X (grid → metros → pixels com margem)
                        int pixelX = (int)(centerX + (xGrid - gridX / 2.0) * cellSize * escala);

                        // 🔸 Converte Z/Y (grid → metros → pixels com inversão vertical + margem)
                        int pixelY = (int)((centerY / 3) + zGrid * cellSize * escala);

                        // 🔸 Tamanho da bbox em pixels
                        int pixelW = (int)(wGrid * cellSize * escala);
                        int pixelH = (int)(hGrid * cellSize * escala);

                        // 🔸 Desenha a bbox
                        var rect = new Rectangle(pixelX, pixelY, pixelW, pixelH);
                        g.DrawRectangle(new Pen(Color.Red, 2), rect);

                        // 🔸 Desenha o centro da bbox
                        int centroX = pixelX + pixelW / 2;
                        int centroY = pixelY + pixelH / 2;
                        g.FillEllipse(Brushes.Red, centroX - 3, centroY - 3, 6, 6);
                    }
                }
            }
            catch
            {

            }*/
            return img;
        }
    }

    public class VisualWorkerMessageRadar2DAnaliseModel
    {
        public List<VisualWorkerMessageAnaliseBBoxModel> bboxes_sombra { get; set; }
        public List<VisualWorkerMessageRadar2DPerfilModel> corredor_perfil { get; set; }
        public VisualWorkerMessageRadar2DGridInfoModel grid_info { get; set; }

        public VisualWorkerMessageRadar2DAnaliseModel Clone()
        {
            return new VisualWorkerMessageRadar2DAnaliseModel()
            {
                bboxes_sombra = new List<VisualWorkerMessageAnaliseBBoxModel>(bboxes_sombra), 
                corredor_perfil = new List<VisualWorkerMessageRadar2DPerfilModel>(corredor_perfil),
                grid_info = grid_info.Clone()
            };
        }
    }

    public class VisualWorkerMessageRadar2DPerfilModel
    {
        public double distancia_m { get; set; }
        public double esquerda_m { get; set; }
        public double direita_m { get; set; }
        public double largura_m { get; set; }
    }

    public class VisualWorkerMessageRadar2DGridInfoModel
    {
        public double escala { get; set; }
        public double img_size { get; set; }
        public double center_x { get; set; }
        public double center_y { get; set; }
        public double cell_size { get; set; }
        public double distancia_max { get; set; }
        public double largura_max { get; set; }
        public VisualWorkerMessageRadar2DGridInfoModel Clone()
        {
            return new VisualWorkerMessageRadar2DGridInfoModel()
            {
                escala = escala, 
                img_size = img_size, 
                center_x = center_x, 
                center_y = center_y,
                cell_size = cell_size, 
                distancia_max = distancia_max,
                largura_max = largura_max
            };
        }
    }

    public class VisualWorkerMessageSegmentacaoSemanticaModel
    {
        public double timestamp { get; set; }
        public int height { get; set; }
        public int width { get; set; }
        public double? erro_angular { get; set; }
        public double? erro_lateral_pct { get; set; }
        public StatusCarroMapa status_corredor { get; set; }
        public StatusCarroMapa status_corredor_anterior { get; set; }
        public VisualWorkerMessageSegmentacaoSemanticaDebugCorredorModel status_corredor_debug { get; set; }
        public List<double?[]> centros_corredor { get; set; }
        public List<int> larguras_px { get; set; }

        public VisualWorkerMessageSegmentacaoSemanticaModel Clone()
        {
            return new VisualWorkerMessageSegmentacaoSemanticaModel()
            {
                timestamp = timestamp,
                height = height,
                width = width,
                erro_angular = erro_angular,
                erro_lateral_pct = erro_lateral_pct,
                status_corredor = status_corredor, 
                status_corredor_anterior = status_corredor_anterior, 
                status_corredor_debug = status_corredor_debug,
                centros_corredor = new List<double?[]>(centros_corredor ?? new List<double?[]>()),
                larguras_px = new List<int>(larguras_px ?? new List<int>()),
            };
        }
    }

    public class VisualWorkerMessageSegmentacaoSemanticaDebugCorredorModel
    {
        public double nav_global { get; set; }
        public double nav_near { get; set; }
        public double nav_mid { get; set; }
        public double nav_far { get; set; }
    }

    public class VisualWorkerMessageMatrizConfiancaModel
    {
        public float ts { get; set; }
        public int seq { get; set; }
        public int grid_w { get; set; }
        public int grid_h { get; set; }
        public List<float> y_range_m { get; set; }
        public List<float> row_dist_m { get; set; }
        public List<float> row_scale_x_m { get; set; }
        public VisualWorkerMessageMatrizConfiancaBlockModel block { get; set; }

        public VisualWorkerMessageMatrizConfiancaModel Clone()
        {
            return new VisualWorkerMessageMatrizConfiancaModel()
            {
                ts = ts,
                seq = seq,
                grid_w = grid_w,
                grid_h = grid_h,
                y_range_m = y_range_m,
                row_dist_m = new List<float>(row_dist_m ?? new List<float>()),
                row_scale_x_m = new List<float>(row_scale_x_m ?? new List<float>()),
                block = block?.Clone() ?? new VisualWorkerMessageMatrizConfiancaBlockModel()
            };
        }
    }

    public class VisualWorkerMessageMatrizConfiancaBlockModel
    {
        public float? d_block_line_m { get; set; }
        public float d_obs_true_min_m { get; set; }
        public bool blocked { get; set; }
        public bool blocked_raw { get; set; }
        public string reason { get; set; }
        public string reason_detail { get; set; }
        public VisualWorkerMessageMatrizConfiancaBlockDecisionModel decision { get; set; }
        public VisualWorkerMessageMatrizConfiancaBlockDecisionTrendModel trend { get; set; }

        public VisualWorkerMessageMatrizConfiancaBlockModel Clone()
        {
            return new VisualWorkerMessageMatrizConfiancaBlockModel()
            {
                d_block_line_m = d_block_line_m,
                d_obs_true_min_m = d_obs_true_min_m,
                blocked = blocked,
                blocked_raw = blocked_raw,
                reason = reason,
                reason_detail = reason_detail,
                decision = decision?.Clone(),
                trend = trend?.Clone()
            };
        }
    }

    public class VisualWorkerMessageMatrizConfiancaBlockDecisionModel
    {
        public bool parar { get; set; }
        public float dist_necessaria { get; set; }
        public float? v_max_sugerida_mps { get; set; }
        public int frames_on { get; set; }
        public int frames_off { get; set; }
        public int N_on { get; set; }
        public int N_off { get; set; }
        public string mode { get; set; }
        public double risk_ema { get; set; }
        public int frames_risk_on { get; set; }

        public VisualWorkerMessageMatrizConfiancaBlockDecisionModel Clone()
        {
            return new VisualWorkerMessageMatrizConfiancaBlockDecisionModel()
            {
                parar = parar,
                dist_necessaria = dist_necessaria,
                v_max_sugerida_mps = v_max_sugerida_mps,
                frames_on = frames_on,
                frames_off = frames_off,
                N_on = N_on,
                N_off = N_off,
                mode = mode,
                frames_risk_on = frames_risk_on,
                risk_ema = risk_ema
            };
        }
    }

    public class VisualWorkerMessageMatrizConfiancaBlockDecisionTrendModel
    {
        public double risk_raw { get; set; }
        public double risk_ema { get; set; }
        public string band { get; set; }
        public double delta_central { get; set; }
        public double delta_side_bias { get; set; }
        public double approaching_obs_m { get; set; }
        public double approaching_det_m { get; set; }
        public int frames_risk_on { get; set; }
        public int frames_risk_off { get; set; }

        public VisualWorkerMessageMatrizConfiancaBlockDecisionTrendModel Clone()
        {
            return new VisualWorkerMessageMatrizConfiancaBlockDecisionTrendModel()
            {
                risk_raw = risk_raw,
                risk_ema = risk_ema,
                band = band,
                delta_central = delta_central,
                delta_side_bias = delta_side_bias,
                approaching_obs_m = approaching_obs_m,
                approaching_det_m = approaching_det_m,
                frames_risk_on = frames_risk_on,
                frames_risk_off = frames_risk_off
            };
        }
    }

    public class VisualWorkerMessageDeteccaoModel
    {
        public int label_id { get; set; }
        public string label { get; set; }
        public double conf { get; set; }
        public List<double> bbox_norm { get; set; }
        public List<double> bbox_px { get; set; }

        public VisualWorkerMessageDeteccaoModel Clone()
        {
            return new VisualWorkerMessageDeteccaoModel()
            {
                label_id = label_id,
                label = label,
                bbox_norm = bbox_norm,
                bbox_px = bbox_px,
                conf = conf
            };
        }
    }


    public enum VisualWorkerCommandType
    {
        ScriptCarregado = 1,
        CalibrarProfundidade = 2,
        IniciarCameraManager = 3,
        AtualizarSaudeCamera = 4,
        GetCameraFrame = 5,
        SaveCameraFrames = 6, 
        EnviarImagemMock = 7
    }

    

}