using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Input;
using Aitex.Core.UI.MVVM;
using Aitex.Core.Utilities;
using MECF.Framework.Simulator.Core.Driver;

namespace MECF.Framework.Simulator.Core.Commons
{
    public class SerialPortDeviceViewModel : TimerViewModelBase
    {
        public ObservableCollection<string> PortList { get; set; }

        public ICommand ClearLogCommand { get; set; }
        public ICommand EnableCommand { get; set; }
        public ICommand DisableCommand { get; set; }

        public ICommand TerminateLogCommand { get; set; }

        public ICommand ResumeLogCommand { get; set; }


        public bool IsEnableEnable
        {
            get { return !_simulator.IsEnabled; }
        }
        public bool IsEnableDisable
        {
            get { return _simulator.IsEnabled; }
        }
 
        public string LocalPort
        {
            get { return _simulator.PortName; }
        }
        public bool IsConnected
        {
            get { return _simulator.IsConnected; }
        }

        public string ConnectionStatus
        {
            get
            {
                if (_simulator.IsEnabled)
                    return "Receiving";

                return "Disable";
            }
        }

        public string PortSetPoint { get; set; }

        public ObservableCollection<TransactionLogItem> TransactionLogItems { get; set; }

        protected BaseSerialSimulator _simulator;

        private int maxItemNumber = 200;

        private bool _terminate = false;

        public SerialPortDeviceViewModel(string name) : base(name)
        {
            ClearLogCommand = new DelegateCommand<string>(ClearLog);
            EnableCommand = new DelegateCommand<string>(Enable);
            DisableCommand = new DelegateCommand<string>(Disable);
            TerminateLogCommand = new DelegateCommand<string>(TerminateLogAction);
            ResumeLogCommand = new DelegateCommand<string>(ResumeLogAction);

            TransactionLogItems = new ObservableCollection<TransactionLogItem>();

            PortSetPoint = "COM2";

            PortList = new ObservableCollection<string>()
            {
                "COM1", "COM2", "COM3", "COM4", "COM5",
                "COM6", "COM7", "COM8", "COM9", "COM10",
                "COM11", "COM12", "COM13", "COM14", "COM15",
                "COM16", "COM17", "COM18", "COM19", "COM20",
                "COM21", "COM22", "COM23", "COM24", "COM25",
            };
        }

        private void TerminateLogAction(string msg)
        {
            _terminate = true;
        }

        private void ResumeLogAction(string msg)
        {
            _terminate = false;
        }

        protected void Init(BaseSerialSimulator sim, bool enable = true)
        {
            PortSetPoint = sim.PortName;
            InvokePropertyChanged("PortSetPoint");

            _simulator = sim;
            _simulator.MessageOut += _simulator_MessageOut;
            _simulator.MessageIn += _simulator_MessageIn;

            if (enable)
                _simulator.Enable();
        }

        private void Disable(string obj)
        {
            _simulator.Disable();
            Poll();
        }

        private void Enable(string obj)
        {
            _simulator.PortName = PortSetPoint;

            _simulator.Enable();
            Poll();
        }

        private void ClearLog(string obj)
        {
            TransactionLogItems.Clear();
        }

        private void _simulator_MessageIn(string obj)
        {
            if(_terminate)
            {
                return;
            }
            Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                TransactionLogItems.Add(new TransactionLogItem() { Incoming = obj, OccurTime = DateTime.Now.ToString("HH:mm:ss.fff") });
                if (TransactionLogItems.Count > maxItemNumber)
                    TransactionLogItems = new ObservableCollection<TransactionLogItem>(TransactionLogItems.Skip(1).Take(maxItemNumber).ToList());
                Poll();
            }));
        }

        private void _simulator_MessageOut(string obj)
        {
            if (_terminate)
            {
                return;
            }
            Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                TransactionLogItems.Add(new TransactionLogItem() { Outgoing = obj, OccurTime = DateTime.Now.ToString("HH:mm:ss.fff") });
                if (TransactionLogItems.Count > maxItemNumber)
                    TransactionLogItems = new ObservableCollection<TransactionLogItem>(TransactionLogItems.Skip(1).Take(maxItemNumber).ToList());
                Poll();
            }));
        }

        protected override void Poll()
        {
            Application.Current.Dispatcher.Invoke(new Action(() =>
            {


                InvokePropertyChanged();

            }));
        }
    }
}