using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Controls;
using System.Numerics;
using System.Windows.Media;
using CtrEditor.HydraulicSimulator;
using CtrEditor.ObjetosSim;
using CtrEditor.FuncionesBase;
using CtrEditor.Simulacion;
using HydraulicSimulator.Models;
using Newtonsoft.Json;
using Xceed.Wpf.Toolkit.PropertyGrid.Attributes;
using CommunityToolkit.Mvvm.ComponentModel;

namespace CtrEditor.ObjetosSim.HydraulicComponents
{
    /// <summary>
    /// Ejemplo de bomba hidráulica que implementa las interfaces del simulador hidráulico
    /// </summary>
    public partial class osPumpExample : osBase, IHydraulicPump, IosBase
    {
        private simPumpExample SimGeometria;
        #region Properties
        
        private double _pumpHead = 50.0; // metros
        private double _maxFlow = 0.01; // m³/s (36 m³/h)
        private double _speedRatio = 1.0;
        private bool _isRunning = true;
        private int _pumpDirection = 1;
        private double _currentFlow = 0.0;
        private double _currentPressure = 0.0;
        
        // Propiedades físicas y visuales
        [ObservableProperty]
        [property: Category("🎨 Apariencia")]
        [property: Description("Ancho de la bomba en metros")]
        [property: Name("Ancho")]
        private float ancho = 0.15f;

        [ObservableProperty]
        [property: Category("🎨 Apariencia")]
        [property: Description("Alto de la bomba en metros")]
        [property: Name("Alto")]
        private float alto = 0.10f;

        [ObservableProperty]
        [property: Category("🎨 Apariencia")]
        [property: Description("Profundidad de la bomba en metros")]
        [property: Name("Profundidad")]
        private float profundidad = 0.08f;

        [ObservableProperty]
        [property: Category("🎨 Apariencia")]
        [property: Description("Color visual de la bomba")]
        [property: Name("Color")]
        private Brush colorButton_oculto = Brushes.Blue;

        [ObservableProperty]
        [property: Category("⚖️ Física")]
        [property: Description("Masa del objeto en kg")]
        [property: Name("Masa")]
        private float mass = 5.0f;

        partial void OnAnchoChanged(float value)
        {
            SimGeometria?.SetDimensions(new Vector3(value, Alto, Profundidad));
        }

        partial void OnAltoChanged(float value)
        {
            SimGeometria?.SetDimensions(new Vector3(Ancho, value, Profundidad));
        }

        partial void OnProfundidadChanged(float value)
        {
            SimGeometria?.SetDimensions(new Vector3(Ancho, Alto, value));
        }

        partial void OnMassChanged(float value)
        {
            SimGeometria?.SetMass(value);
        }
        
        [Category("🔧 Bomba Hidráulica")]
        [DisplayName("Cabeza de bomba")]
        [Description("Cabeza de la bomba a caudal cero (m)")]
        public double PumpHead
        {
            get => _pumpHead;
            set
            {
                if (SetProperty(ref _pumpHead, Math.Max(0, value)))
                {
                    InvalidateHydraulicNetwork();
                }
            }
        }
        
        [Category("🔧 Bomba Hidráulica")]
        [DisplayName("Caudal máximo")]
        [Description("Caudal máximo de la bomba (m³/s)")]
        public double MaxFlow
        {
            get => _maxFlow;
            set
            {
                if (SetProperty(ref _maxFlow, Math.Max(0.001, value)))
                {
                    InvalidateHydraulicNetwork();
                }
            }
        }
        
        [Category("🔧 Bomba Hidráulica")]
        [DisplayName("Velocidad relativa")]
        [Description("Velocidad relativa de la bomba (0.0 a 1.0)")]
        public double SpeedRatio
        {
            get => _speedRatio;
            set
            {
                SetProperty(ref _speedRatio, Math.Max(0.0, Math.Min(1.0, value)));
            }
        }
        
        [Category("🔧 Bomba Hidráulica")]
        [DisplayName("Funcionando")]
        [Description("Indica si la bomba está encendida")]
        public bool IsRunning
        {
            get => _isRunning;
            set
            {
                SetProperty(ref _isRunning, value);
            }
        }
        
        [Category("🔧 Bomba Hidráulica")]
        [DisplayName("Dirección")]
        [Description("Dirección de la bomba (+1 o -1)")]
        [ItemsSource(typeof(PumpDirectionItemsSource))]
        public int PumpDirection
        {
            get => _pumpDirection;
            set
            {
                if (SetProperty(ref _pumpDirection, value == -1 ? -1 : 1))
                {
                    InvalidateHydraulicNetwork();
                }
            }
        }
        
        [Category("📊 Estado Actual")]
        [DisplayName("Caudal actual")]
        [Description("Caudal actual de la bomba (m³/s)")]
        [JsonIgnore]
        public double CurrentFlow
        {
            get => _currentFlow;
            private set => SetProperty(ref _currentFlow, value);
        }
        
        [Category("📊 Estado Actual")]
        [DisplayName("Presión actual")]
        [Description("Presión actual en la bomba (Pa)")]
        [JsonIgnore]
        public double CurrentPressure
        {
            get => _currentPressure;
            private set => SetProperty(ref _currentPressure, value);
        }
        
        [Category("📊 Estado Actual")]
        [DisplayName("Presión (bar)")]
        [Description("Presión actual en la bomba (bar)")]
        [JsonIgnore]
        public double CurrentPressureBar => CurrentPressure / 100000.0;
        
        [Category("📊 Estado Actual")]
        [DisplayName("Caudal (L/min)")]
        [Description("Caudal actual en L/min")]
        [JsonIgnore]
        public double CurrentFlowLMin => CurrentFlow * 60000.0; // m³/s a L/min
        
        #endregion
        
        #region Constructor y Métodos Base

        private string nombre = NombreClase();

        [Category("🏷️ Identificación")]
        [Description("Nombre identificativo del objeto")]
        [Name("Nombre")]
        public override string Nombre
        {
            get => nombre;
            set => SetProperty(ref nombre, value);
        }

        public override void OnMove(float LeftPixels, float TopPixels)
        {
            UpdateAfterMove();
        }

        public override void OnResize(float Delta_Width, float Delta_Height)
        {
            Ancho += Delta_Width;
            Alto += Delta_Height;
        }

        public Vector2 GetCentro()
        {
            return new Vector2(Left + Ancho / 2, Top + Alto / 2);
        }

        public void SetCentro(float x, float y)
        {
            Left = x - Ancho / 2;
            Top = y - Alto / 2;
        }

        public void SetCentro(Vector2 centro)
        {
            Left = centro.X - Ancho / 2;
            Top = centro.Y - Alto / 2;
        }

        private void ActualizarGeometrias()
        {
            if (SimGeometria != null && !RemoverDesdeSimulacion)
            {
                SimGeometria.SetPosition(GetCentro());
            }
        }

        public osPumpExample()
        {
            Nombre = "Bomba Hidráulica";
        }

        public void UpdateAfterMove()
        {
            if (!RemoverDesdeSimulacion)
            {
                ActualizarGeometrias();
                SimGeometria?.SetDimensions(new Vector3(Ancho, Alto, Profundidad));
            }
        }

        public override void UpdateGeometryStart()
        {
            // Se llama cuando inicia la simulación - crear geometría si no existe
            if (SimGeometria == null)
            {
                SimGeometria = simulationManager.AddPumpExample(new Vector3(Ancho, Alto, Profundidad), GetCentro(), Mass);
                SimGeometria.SimObjectType = "PumpExample";
                SimGeometria.WpfObject = this;
            }
            else
            {
                ActualizarGeometrias();
                SimGeometria?.SetDimensions(new Vector3(Ancho, Alto, Profundidad));
                SimGeometria?.SetMass(Mass);
            }
        }

        public override void UpdateGeometryStep()
        {
            // Se llama durante cada paso de la simulación
            if (SimGeometria != null)
            {
                // Actualizar posición desde la simulación hacia WPF
                SetCentro(SimGeometria.Center);
                
                // Actualizar propiedades hidráulicas en la simulación
                SimGeometria.UpdateHydraulicProperties(PumpHead, MaxFlow, SpeedRatio, IsRunning, PumpDirection);
                
                // Obtener resultados de la simulación hidráulica
                CurrentFlow = SimGeometria.GetCurrentFlow();
                CurrentPressure = SimGeometria.GetCurrentPressure();
            }
        }

        public override void UpdateControl(int elapsedMilliseconds)
        {
            if (SimGeometria != null)
            {
                SetCentro(SimGeometria.Center);
                
                // Actualizar el color según el estado
                if (IsRunning)
                    ColorButton_oculto = Brushes.Green;
                else
                    ColorButton_oculto = Brushes.Gray;
                
                // Actualizar valores actuales desde la simulación
                CurrentFlow = SimGeometria.GetCurrentFlow();
                CurrentPressure = SimGeometria.GetCurrentPressure();
            }
        }

        public override void ucLoaded()
        {
            // El UserControl ya se ha cargado y podemos obtener las coordenadas para 
            // crear el objeto de simulacion
            base.ucLoaded();
            SimGeometria = simulationManager.AddPumpExample(new Vector3(Ancho, Alto, Profundidad), GetCentro(), Mass);
        }

        public override void ucUnLoaded()
        {
            // El UserControl se esta eliminando
            // eliminar el objeto de simulacion
            simulationManager.Remove(SimGeometria);
        }

        #endregion
        
        #region IHydraulicComponent Implementation
        
        [JsonIgnore]
        public bool HasHydraulicComponents => true;
        
        public List<HydraulicNodeDefinition> GetHydraulicNodes()
        {
            var nodes = new List<HydraulicNodeDefinition>
            {
                new HydraulicNodeDefinition($"{Nombre}_In", false, null, "Entrada de la bomba"),
                new HydraulicNodeDefinition($"{Nombre}_Out", false, null, "Salida de la bomba")
            };
            
            return nodes;
        }
        
        public List<HydraulicElementDefinition> GetHydraulicElements()
        {
            var elements = new List<HydraulicElementDefinition>();
            
            if (HasHydraulicComponents)
            {
                // Crear bomba con parámetros actuales
                var pump = new PumpHQ(
                    h0: PumpHead,
                    q0: MaxFlow,
                    speedRel: IsRunning ? SpeedRatio : 0.0, // Si no está funcionando, velocidad = 0
                    direction: PumpDirection
                );
                
                var pumpElement = new HydraulicElementDefinition(
                    $"{Nombre}_Pump",
                    $"{Nombre}_In",
                    $"{Nombre}_Out",
                    pump,
                    $"Bomba {Nombre}"
                );
                
                elements.Add(pumpElement);
            }
            
            return elements;
        }
        
        public void UpdateHydraulicProperties()
        {
            // Aquí se pueden hacer validaciones o ajustes antes de la simulación
            if (!IsRunning)
            {
                SpeedRatio = 0.0;
            }
            
            if (SpeedRatio < 0.0) SpeedRatio = 0.0;
            if (SpeedRatio > 1.0) SpeedRatio = 1.0;
            
            Debug.WriteLine($"Bomba {Nombre}: Velocidad={SpeedRatio:F2}, Funcionando={IsRunning}");
        }
        
        public void ApplyHydraulicResults(Dictionary<string, double> flows, Dictionary<string, double> pressures)
        {
            // Buscar resultados para esta bomba
            string pumpBranchName = $"{Nombre}_Pump";
            string inletNodeName = $"{Nombre}_In";
            string outletNodeName = $"{Nombre}_Out";
            
            if (flows.ContainsKey(pumpBranchName))
            {
                CurrentFlow = flows[pumpBranchName];
            }
            
            if (pressures.ContainsKey(inletNodeName))
            {
                CurrentPressure = pressures[inletNodeName];
            }
            else if (pressures.ContainsKey(outletNodeName))
            {
                CurrentPressure = pressures[outletNodeName];
            }
        }
        
        #endregion
        
        #region IHydraulicFlowReceiver Implementation
        
        public void SetFlow(double flow)
        {
            CurrentFlow = flow;
        }
        
        public double GetFlow()
        {
            return CurrentFlow;
        }
        
        #endregion
        
        #region IHydraulicPressureReceiver Implementation
        
        public void SetPressure(double pressure)
        {
            CurrentPressure = pressure;
        }
        
        public double GetPressure()
        {
            return CurrentPressure;
        }
        
        #endregion
        
        #region Helper Methods
        
        /// <summary>
        /// Invalida la red hidráulica para forzar reconstrucción
        /// </summary>
        private void InvalidateHydraulicNetwork()
        {
            // Si tenemos acceso al MainViewModel, invalidar la red
            if (_mainViewModel?.hydraulicSimulationManager != null)
            {
                _mainViewModel.hydraulicSimulationManager.InvalidateNetwork();
            }
        }
        
        #endregion
        
        #region Static Interface Implementation
        
        public static string NombreClase() => "Bomba Hidráulica";
        public static string NombreCategoria() => "Componentes Hidráulicos";
        
        #endregion
    }
    
    /// <summary>
    /// Proveedor de items para la dirección de la bomba
    /// </summary>
    public class PumpDirectionItemsSource : IItemsSource
    {
        public Xceed.Wpf.Toolkit.PropertyGrid.Attributes.ItemCollection GetValues()
        {
            var items = new Xceed.Wpf.Toolkit.PropertyGrid.Attributes.ItemCollection();
            items.Add(1, "Adelante (+1)");
            items.Add(-1, "Atrás (-1)");
            return items;
        }
    }
}