using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using Tango.BL.Entities;
using Tango.BL.Enumerations;
using Tango.FSE.Common.Diagnostics;
using Tango.FSE.Common.Notifications;
using Tango.PMR.Diagnostics;

namespace Tango.FSE.Diagnostics.Project.Widgets.Output
{
    [Description("Digital Output Controller")]
    public class OutputWidget : DiagnosticsWidget, ISupportsComponentSelection<TechIos>
    {
        public TechIos IO { get; set; } = TechIos.GPO_LED1;

        private TechIo _techIO;
        [JsonIgnore]
        public TechIo TechIo
        {
            get { return _techIO; }
            set { _techIO = value; RaisePropertyChangedAuto(); RaisePropertyChanged(nameof(DisplayName)); }
        }

        [JsonIgnore]
        public override string DisplayName
        {
            get
            {
                return this.TechIo != null ? this.TechIo.InterfaceName : String.Empty;
            }
        }

        private bool _value;
        [JsonIgnore]
        public bool Value
        {
            get { return _value; }
            set
            {
                if (_value != value)
                {
                    _value = value;
                    RaisePropertyChangedAuto();
                    OnValueChanged();
                }
            }
        }

        private bool _effectiveValue;
        [JsonIgnore]
        public bool EffectiveValue
        {
            get { return _effectiveValue; }
            set
            {
                if (_effectiveValue != value)
                {
                    _effectiveValue = value;
                    RaisePropertyChangedAuto();
                    _value = value;
                    RaisePropertyChanged(nameof(Value));
                }
            }
        }

        public override async Task Init()
        {
            int io = (int)IO;
            TechIo = await Services.TechComponentsService.IOs.FindOne(x => x.Code == io);
        }

        public override void OnDiagnosticsData(DiagnosticsPackage package)
        {
            var state = package.GetDigitalInterfaceState(IO);

            if (state != null)
            {
                EffectiveValue = state.Value;
            }
        }

        private async void OnValueChanged()
        {
            if (MachineProvider.IsConnected)
            {
                try
                {
                    await MachineProvider.MachineOperator.SetDigitalOut(new SetDigitalOutRequest() { InterfaceIO = (InterfaceIOs)IO, Value = Value });
                }
                catch (Exception ex)
                {
                    LogManager.Log(ex, "Error setting digital output state.");
                    NotificationProvider.PushSnackbarItem(MessageType.Error, "Digital Output Controller Error", true, ex.Message, TimeSpan.FromSeconds(5));
                }
            }
        }

        public override FrameworkElement GetView()
        {
            return new OutputWidgetView();
        }

        #region Component Selection

        public List<DiagnosticsWidgetComponent<TechIos>> Components
        {
            get
            {
                return Services.TechComponentsService.IOs.FindAll().Result.Where(x => x.Type == (int)IOType.DigitalOutput).Select(x => new DiagnosticsWidgetComponent<TechIos>()
                {
                    DisplayName = x.InterfaceName,
                    Object = (TechIos)x.Code,
                }).OrderByAlphaNumeric(x => x.DisplayName).ToList();
            }
        }

        public TechIos SelectedComponent
        {
            get
            {
                return IO;
            }
            set
            {
                if (IO != value)
                {
                    IO = value;
                    InitAsync();
                }
            }
        }

        public bool EnableComponentSelection { get; set; }

        #endregion
    }
}