using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using System.Windows;
using Aurora.View;
using Aurora;
using System.Windows.Threading;
using System.Windows.Input;
using Aurora.Api;
using System.Reactive.Linq;

namespace WeldingCommon.Views
{
    public class LastPositionConverter : IValueConverter
    {
        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
        {
            if (value is eWorkingPosition wpValue) {
                if (wpValue < eWorkingPosition.DONE) {
                    return Visibility.Visible;
                }
            }

            return Visibility.Collapsed;
        }

        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }

    public class UCWorkPosViewModel : NotifyPropertyChangedBase
    {
        private IAuroraEnvironment _Aurora;
        private readonly DispatcherTimer _MonitorTimer;

        public ICommand CMD_VisibleChanged { get; }

        public Dictionary<eWorkingPosition, BlinkModel> WorkingPositions { get; set; } = new Dictionary<eWorkingPosition, BlinkModel>();
        private eWorkingPosition PrevPosition = eWorkingPosition.NONE;

        public UCWorkPosViewModel(IAuroraEnvironment aurora, string seqeunceId)
        {
            _Aurora = aurora;

            var _MainSeq = _Aurora.SequenceEntry[seqeunceId];
            if (_MainSeq != null) {
                _MainSeq.RunStateChanged += OnMainSequenceChanged;
            }

            for (eWorkingPosition i = eWorkingPosition.NONE + 1; i < eWorkingPosition.MAX; i++) {
                WorkingPositions.Add(i, new BlinkModel());
            }

            InitWorkingPosition(Status.GetWorkingPosition());

            CMD_VisibleChanged = new DelegateCommand(VisibleChanged);

            _MonitorTimer = new DispatcherTimer();
            _MonitorTimer.Tick += OnMonitoring;
            _MonitorTimer.Interval = TimeSpan.FromMilliseconds(300);
            _MonitorTimer.Start();

            _Aurora.EventObservable.AsObservable(EquipEvent.WORKING_POS_UPDATED)
                .Subscribe(x => UpdateWorkingPosition());

            _Aurora.EventObservable.AsObservable(AuroraSysEvent.SYS_LANGUAGE_CHANGED)
                .Select(msg => msg.Param.ToString().Split('-').First().ToLower())
                .ObserveOnDispatcher().Subscribe(lan => UpdateLanguage());
        }

        private void InitWorkingPosition(eWorkingPosition workingPos)
        {
            foreach (var item in WorkingPositions) {
                if (item.Key != workingPos) {
                    item.Value.IsActivated = false;
                    item.Value.IsRunning = false;
                } else {
                    item.Value.IsActivated = true;
                    item.Value.IsRunning = true;
                }
            }
        }

        private void OnMainSequenceChanged(object sender, (string sequenceId, SequenceRunState state) e)
        {
            Application.Current.Dispatcher.InvokeAsync(() => {
                if (e.state != SequenceRunState.Running) {
                    foreach (var item in WorkingPositions) {
                        item.Value.IsActivated = false;
                        item.Value.IsRunning = false;
                    }
                }
            });
        }

        private void VisibleChanged(object obj)
        {
            bool visible = (bool)obj;
            if (visible) {
                if (!_MonitorTimer.IsEnabled) {
                    _MonitorTimer.Start();
                }
            } else {
                if (_MonitorTimer.IsEnabled) {
                    _MonitorTimer.Stop();
                }
            }
        }

        private void OnMonitoring(object sender, EventArgs e)
        {

        }

        private void UpdateWorkingPosition()
        {
            var workingPos = Status.GetWorkingPosition();
            Application.Current.Dispatcher.InvokeAsync(() => {
                if (workingPos == PrevPosition) {
                    return;
                }

                InitWorkingPosition(workingPos);
                PrevPosition = workingPos;
            });
        }

        private void UpdateLanguage()
        {
            WorkingPositions[eWorkingPosition.CHECKING_CONDITION].Position = Application.Current.FindStrToken("CheckingCondition");

            WorkingPositions[eWorkingPosition.LOADING_CELL].Position = Application.Current.FindStrToken("LoadingCell");
            WorkingPositions[eWorkingPosition.UPLOADING_WELD_LIST].Position = Application.Current.FindStrToken("UploadingWeldList");
            WorkingPositions[eWorkingPosition.EXECUTING_WELD].Position = Application.Current.FindStrToken("ExecutingWeld");
            WorkingPositions[eWorkingPosition.UNLOADING_CELL].Position = Application.Current.FindStrToken("UnloadCell");

            WorkingPositions[eWorkingPosition.REPORTING_RESULT].Position = Application.Current.FindStrToken("ReportingResult");
            WorkingPositions[eWorkingPosition.CHECKING_CYCLE].Position = Application.Current.FindStrToken("CheckingCycle");

            WorkingPositions[eWorkingPosition.DONE].Position = Application.Current.FindStrToken("Done");
        }

    }
}