using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Prism.Mvvm;
using System.Threading.Tasks;
using Prism.Events;
using Prism.Ioc;
using Prism.Regions;
using LampInspectionMachine.Model;
using System.Threading;
using LampInspectionMachine.Log4xml;
using System.Diagnostics;
using System.IO.Ports;
using LampInspectionMachine.HttpService;
using System.IO;
using System.Net;
using Newtonsoft.Json;

using System.Collections.ObjectModel;
using LampInspectionMachine.Views;
using Microsoft.Xaml.Behaviors;
using System.Collections.Specialized;
using System.Windows.Controls;
using LampInspectionMachine.Core;
using Prism.Commands;
using MvCamCtrl.NET;
using System.Windows;

namespace LampInspectionMachine.ViewModels
{
    public class WorkRunViewModel : BindableBase, INavigationAware
    {
        private AppData _appData;
        private IContainerProvider _container;
        private IEventAggregator _eventAggregator;
        private IRegionManager _regionManager;
        private Management management;

        private Stopwatch[]IOChecksTime=new Stopwatch[50];
        private string CheckOrderCode=string.Empty;

        private ObservableCollection<string> _Logs = new ObservableCollection<string>();
        public ObservableCollection<string> Logs { get => _Logs; set => _Logs = value; }



        private DelegateCommand _ClearViewCommand;
        public DelegateCommand ClearViewCommand =>
            _ClearViewCommand ?? (_ClearViewCommand = new DelegateCommand(ClearOKAndNGMethod));



        public DelegateCommand LoadedCommand { get; set; }
        public Management Management { get => management; set { SetProperty(ref management, value); } }

        private bool IsLoad=false;

        public WorkRunViewModel(IContainerProvider container, IRegionManager regionManager, IEventAggregator eventAggregator)
        {
            _container = container;
            _eventAggregator = eventAggregator;
            _regionManager = regionManager;
            _appData = _container.Resolve<AppData>();
            Management = _container.Resolve<Management>();
            LogHelper.logChangHandler += ShowLog;
            LoadedCommand = new DelegateCommand(OnLoad);
        }

        private async void OnLoad()
        {
            if ( !IsLoad )
            {
                LogHelper.Info("程序启动");
                management.LoadCameraDevice();
                management.ConnectPlc();
                
                TipService tipService = new TipService();
                await Task.Run(() => { Management.InitTemplates(tipService, Management); });
            }
            IsLoad = true;
           
        }
        private void ShowLog(Log4xml.Log log)
        {
            System.Windows.Application.Current.Dispatcher.Invoke(new Action(() =>
            {
                if (Logs.Count > 100)
                {
                    Logs.Clear();
                }
                string str = log.Msg.Trim().Replace("相机",Resources.Language.Resources.相机); ;
                Logs.Add(str);    
                
            }));

        }
        private void ClearOKAndNGMethod() 
        {

            for (int i = 0; i < management.VisionProManagers.Count; i++)
            {
                management.VisionProManagers[i].IsOkCount = 0;
                management.VisionProManagers[i].IsNgCount = 0;
            }
        
        }
        public bool IsNavigationTarget(NavigationContext navigationContext)
        {
            return IsLoad;
        }

        public void OnNavigatedFrom(NavigationContext navigationContext)
        {
            //停止运行
        }

        public void OnNavigatedTo(NavigationContext navigationContext)
        {
            try
            {
                //继续运行
                for (int i = 0; i < Management.VisionProManagers.Count; i++)
                {
                    if (Management.VisionProManagers[i].Camera != null && Management.VisionProManagers[i].Camera.IsConnected)
                    {
                        //Management.VisionProManagers[i].Camera.StopGrabbing();
                        //if (!Management.VisionProManagers[i].Camera.IsGrabbing)
                        //{
                            Management.VisionProManagers[i].Camera.SetTriggerMode(true, 0);
                            Management.VisionProManagers[i].CameraInfo.TriggerMode = true;
                            if (!Management.VisionProManagers[i].Camera.CheckGrabImageCallbackEventIsHas(Management.VisionProManagers[i].ImageCallback))
                                Management.VisionProManagers[i].Camera.GrabImageCallbackEvent += Management.VisionProManagers[i].ImageCallback;
                        //    management.VisionProManagers[i].Camera.StartTriggerGrabbing();
                        //}
                        if (Management.VisionProManagers[i].Camera.CheckImageCallbackEventIsHas(Management.VisionProManagers[i].CamCallBack))
                        {
                            Management.VisionProManagers[i].Camera.ImageCallbackEvent -= Management.VisionProManagers[i].CamCallBack;
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                LogHelper.Error("切换运行界面出错" + ex.Message);
                MessageBox.Show("切换运行界面出错"+ex.Message);
            }
        }










    }

    public class AutoScrollBehavior : Behavior<ListBox>
    {
        protected override void OnAttached()
        {
            base.OnAttached();
            var items = AssociatedObject.Items;
            if ( items is INotifyCollectionChanged incc )
            {
                incc.CollectionChanged += OnCollectionChanged;
            }
        }
        bool isend = true;
        private void OnCollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
        {
            if ( e.Action == NotifyCollectionChangedAction.Add && AssociatedObject.HasItems )
            {
                if (isend)
                {
                    isend = false;
                    AssociatedObject.Dispatcher.BeginInvoke(new Action(() =>
                    {
                        AssociatedObject.UpdateLayout();
                        AssociatedObject.ScrollIntoView(AssociatedObject.Items[AssociatedObject.Items.Count - 1]);
                        isend = true;
                    }));
                }

            }
        }

        protected override void OnDetaching()
        {
            if ( AssociatedObject.Items is INotifyCollectionChanged incc )
            {
                incc.CollectionChanged -= OnCollectionChanged;
            }
            base.OnDetaching();
        }
    }
}