using FISLib;
using FISLib.AfterSales;
using FISLib.Connect;
using FISLib.Hardware;
using FISLib.LiveVideo;
using FISLib.Remedical;
using FISLib.Vid;
using FISSDKDemoV2.AfterSalesImplement;
using FISSDKDemoV2.Database.Entity;
using FISSDKDemoV2.Database.IRespository;
using FISSDKDemoV2.Helper;
using FISSDKDemoV2.Model;
using FISSDKDemoV2.Model.Log;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading;
using System.Windows;

namespace FISSDKDemoV2.Manager
{
    internal class FISManager
    {
        private static FISManager _instance;

        private bool _isEncryptedShow;

        private FISConnectionInfo _connectionInfo;

        private bool _tempConnectStatus;

        private IExamImageInfoDatabaseService _examImageInfoDatabaseService;

        internal static FISManager Instance => _instance ?? (_instance = new FISManager());

        internal FISProxy FISProxy { get; private set; }

        internal IFISConnect FISConnect { get; private set; }

        internal IFISRemedical FISRemedical { get; private set; }

        internal IFISVid FISVid { get; private set; }

        internal IFISLiveVideo FISLiveVideo { get; private set; }

        internal IFISHardwareDetector FISHardwareDetector { get; private set; }

        internal IFISAfterSales FISAfterSales { get; private set; }

        internal bool IsConnected => DeviceStatus == DeviceStatus.Logon;

        internal DeviceStatus DeviceStatus { get; private set; }

        internal bool IsEncryptedShow
        {
            get
            {
                return _isEncryptedShow;
            }
            set
            {
                if (_isEncryptedShow != value)
                {
                    _isEncryptedShow = value;
                }
            }
        }

        internal UltrasoundMachineInfo UltrasoundMachineInfo { get; private set; }

        internal event EventHandler<DeviceStatus> DeviceStatusChanged;

        internal event EventHandler<FISLogEventArgs> FISLogInfoNotificated;

        internal event EventHandler<ExamImageInfo> ExamImageInfoStatusChanged;

        internal event EventHandler<FISLiveNotificationArgs> ConsultaitonLiveNotification;

        internal event EventHandler<FISVideoFrameData> PreviewCameraCaptured;

        internal void Init()
        {
            _examImageInfoDatabaseService = DataBaseManager.GetService<IExamImageInfoDatabaseService>();
            FIS.UpgradeFinished += OnUpgradeFinished;
            FIS.FISLogInfoNotificated += OnFISLogInfoNotificated;
            FIS.FISAbnormalCrashed += OnFISAbnormalCrashed;
            FIS.RestartedAfterCrashed += OnRestartedAfterCrashed;
            var fisFolder = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "FIS");
            if (!Directory.Exists(fisFolder))
            {
                Directory.CreateDirectory(fisFolder);
            }
            var cpuId = HardwareHelper.GetCPUId();
            var cpuName = HardwareHelper.GetCpuName();
            var rootPath = Path.GetPathRoot(AppDomain.CurrentDomain.BaseDirectory);
            var fisLogPath = Path.Combine(rootPath, "FISLogFolder");
            if (!Directory.Exists(fisLogPath))
            {
                Directory.CreateDirectory(fisLogPath);
            }
            var screenWidth = FISSDKDemoSettings.Instance.Width == 0 ? 1280 : FISSDKDemoSettings.Instance.Width;
            var screenHeight = FISSDKDemoSettings.Instance.Height == 0 ? 720 : FISSDKDemoSettings.Instance.Height;
            UltrasoundMachineInfo = new UltrasoundMachineInfo(string.Empty, "", true, string.Empty, "USDemoV2", "2.11.0", "2.2.27.5", cpuName, screenWidth, screenHeight, fisFolder, fisLogPath, FISLoginSourceV2.PC, FISPlatform.Windows, "US");
            var fisAfterSalesTaskLibs = new List<IFISAfterSalesTask>
            {
                new ExecutePrinterSettingTask(),
                new ExecuteProbeApplicationSettingTask(),
                new ExecuteProbeApplicationTask(),
                new ExecuteSystemSettingTask(),
                new GetLogTask(),
                new GetDeviceScreenShotTask(),
                new PushPatchTask(),
                new RunExecuteApiTask(),
                new UpdateMonitorRGBTask()
            };
            FISProxy = FIS.Enable(UltrasoundMachineInfo, fisAfterSalesTaskLibs);
            if (FISProxy == null)
            {
                throw new Exception("FIS Enable Failed");
            }
            FISProxy.FeatureUpdated += OnFeatureUpdated;
            FISConnect = FISProxy.GetFISConnect();
            FISConnect.StatusChanged += OnStatusChanged;
            FISVid = FISProxy.GetFISVid();
            FISHardwareDetector = FISProxy.GetFISHardwareDetector();
            DeviceStatus = DeviceStatus.Offline;
        }

        private void OnFeatureUpdated(object sender, FISFeatureUpdatedInfo e)
        {
            var createFeatureList = e.CreateFeatureList?.ToList();
            var disposeFeatureList = e.DisposeFeatureList?.ToList();
            foreach (var createFeature in createFeatureList)
            {
                switch (createFeature)
                {
                    case FISFeature.Remedical:
                        CreateFISRemedical();
                        break;

                    case FISFeature.LiveVideo:
                        CreateFISLiveVideo();
                        break;

                    case FISFeature.AfterSales:
                        CreateFISAfterSales();
                        break;
                }
            }

            foreach (var disposeFeature in disposeFeatureList)
            {
                switch (disposeFeature)
                {
                    case FISFeature.Remedical:
                        DisposeFISRemedical();
                        break;

                    case FISFeature.LiveVideo:
                        DisposeFISLiveVideo();
                        break;

                    case FISFeature.AfterSales:
                        DisposeFISAfterSales();
                        break;
                }
            }
        }

        private void CreateFISRemedical()
        {
            if (FISRemedical == null)
            {
                FISRemedical = FISProxy.GetFISRemedical();
                FISRemedical.FISScanDataChanged += OnFISScanDataChanged;
            }
        }

        private void CreateFISLiveVideo()
        {
            if (FISLiveVideo == null)
            {
                FISLiveVideo = FISProxy.GetFISLiveVideo();
                FISLiveVideo.LiveNotification += OnLiveNotification;
                FISLiveVideo.PreviewCameraCaptured += OnPreviewCameraCaptured;
            }
        }

        private void CreateFISAfterSales()
        {
            if (FISAfterSales == null)
            {
                FISAfterSales = FISProxy.GetFISAfterSales();
                FISAfterSales.CurrentTaskChanged += OnCurrentTaskChanged;
                FISAfterSales.MasterChanged += OnMasterChanged;
            }
        }

        private void DisposeFISRemedical()
        {
            if (FISRemedical != null)
            {
                FISRemedical.FISScanDataChanged -= OnFISScanDataChanged;
                FISRemedical.Dispose();
                FISRemedical = null;
            }
        }

        private void DisposeFISLiveVideo()
        {
            if (FISLiveVideo != null)
            {
                FISLiveVideo.LiveNotification -= OnLiveNotification;
                FISLiveVideo.PreviewCameraCaptured -= OnPreviewCameraCaptured;
                FISLiveVideo.Dispose();
                FISLiveVideo = null;
            }
        }

        private void DisposeFISAfterSales()
        {
            if (FISAfterSales == null)
            {
                FISAfterSales.CurrentTaskChanged -= OnCurrentTaskChanged;
                FISAfterSales.MasterChanged -= OnMasterChanged;
                FISAfterSales.Dispose();
                FISAfterSales = null;
            }
        }

        private void OnCurrentTaskChanged(object sender, FISAfterSalesTask e)
        {
            Logger.WriteLineInfo($"FISManager OnCurrentTaskChanged,Current Task is {e.Type}");
        }

        private void OnMasterChanged(object sender, FISMasterInfo e)
        {
            Logger.WriteLineInfo($"FISManager OnMasterChanged,Current UserId is {e?.UserId},UserName:{e?.UserName}");
        }

        private void OnPreviewCameraCaptured(object sender, FISVideoFrameData e)
        {
            if (e != null)
            {
                PreviewCameraCaptured?.Invoke(this, e);
            }
        }

        private void OnLiveNotification(object sender, FISLiveNotificationArgs e)
        {
            ConsultaitonLiveNotification?.Invoke(this, e);
        }

        private void OnStatusChanged(object sender, DeviceStatus e)
        {
            Logger.WriteLineInfo($"FISManager OnStatusChanged :{e}");
            DeviceStatus = e;
            if (e == DeviceStatus.Logon)
            {
                var cameraSetting = new CameraSetting(FIS.FISSettingsInfo.LiveVideoEnabled, FIS.FISSettingsInfo.CameraEnabled, FIS.FISSettingsInfo.LiveConfiguration.LiveCameraInfo, FIS.FISSettingsInfo.LiveConfiguration.LiveMicInfo, FIS.FISSettingsInfo.CameraPreviewEnabled, FIS.FISSettingsInfo.LiveConfiguration.IsMute);
                FISLiveVideo.ChangeCameraSetting(cameraSetting);
            }
            DeviceStatusChanged?.Invoke(this, e);
        }

        private void OnUpgradeFinished(object sender, EventArgs e)
        {
            Logger.WriteLineError($"OnUpgradeFinished Invoke");
        }

        private void OnFISLogInfoNotificated(object sender, FISLogEventArgs e)
        {
            var errorMsg = $"OnFISLogInfoNotificated:Log Type:{e.LogType},Log Content:{e.Msg} ";
            switch (e.LogType)
            {
                case FISDeviceLogCategory.Info:
                    Logger.WriteLineInfo(errorMsg);
                    break;

                case FISDeviceLogCategory.Warn:
                    Logger.WriteLineWarn(errorMsg);
                    break;

                case FISDeviceLogCategory.Error:
                    Logger.WriteLineError(errorMsg);
                    break;

                case FISDeviceLogCategory.Verb:
                    Logger.WriteLineVerbose(errorMsg);
                    break;
            }
            FISLogInfoNotificated?.Invoke(this, e);
        }

        private void OnFISAbnormalCrashed(object sender, EventArgs e)
        {
            _tempConnectStatus = FIS.FISSettingsInfo.IsConnected;
            Logger.WriteLineError($"OnFISAbnormalCrashed Invoke");
            if (FISProxy != null)
            {
                FISProxy.FeatureUpdated += OnFeatureUpdated;
                FISProxy = null;
            }
            if (FISConnect != null)
            {
                FISConnect.StatusChanged -= OnStatusChanged;
                FISConnect = null;
            }
            if (FISVid != null)
            {
                FISVid = null;
            }
            if (FISHardwareDetector != null)
            {
                FISHardwareDetector = null;
            }
            if (FISRemedical != null)
            {
                FISRemedical.FISScanDataChanged -= OnFISScanDataChanged;
                FISRemedical = null;
            }
            if (FISLiveVideo != null)
            {
                FISLiveVideo.PreviewCameraCaptured -= OnPreviewCameraCaptured;
                FISLiveVideo.LiveNotification -= OnLiveNotification;
                FISLiveVideo = null;
            }
            OnStatusChanged(this, DeviceStatus.Offline);
            MessageBox.Show("FIS Exe Abnormal Crashed", "提示", MessageBoxButton.OK, MessageBoxImage.Error);
        }

        private void OnFISScanDataChanged(object sender, FISVidDataChangedEventArgs e)
        {
            try
            {
                if (e == null)
                {
                    return;
                }
                var examImageInfo = _examImageInfoDatabaseService.GetExamImageByScanDataId(e.FISVidData.Id);
                if (examImageInfo == null)
                {
                    Logger.WriteLineError($"OnFISSVidDataChanged GetExamImageByScanDataId Result is null 1stTime.");
                    Thread.Sleep(1000);
                    examImageInfo = _examImageInfoDatabaseService.GetExamImageByScanDataId(e.FISVidData.Id);
                    if (examImageInfo == null)
                    {
                        Logger.WriteLineError($"OnFISSVidDataChanged GetExamImageByScanDataId Result is null last Time.");
                        return;
                    }
                }
                Logger.WriteLineInfo($"OnFISSVidDataChanged Current ExamImageInfo,ExamImageId:{examImageInfo.Id},ExamId:{examImageInfo.ExamId},ScanDataId:{examImageInfo.ScanDataId}");
                examImageInfo.UploadResult = e.FISVidData.Status;
                Logger.WriteLineInfo($"OnFISSVidDataChanged Action:{e.ChangeType}, ScanDataId:{e.FISVidData.Id},Upload Status:{e.FISVidData.Status}");
                _examImageInfoDatabaseService.Update(examImageInfo);
                ExamImageInfoStatusChanged?.Invoke(this, examImageInfo);
            }
            catch (Exception ex)
            {
                Logger.WriteLineError(ex.ToString());
                FISLogInfoNotificated?.Invoke(this, new FISLogEventArgs(FISDeviceLogCategory.Error, $"FISManager OnFISScanDataChanged Error:{ex}"));
            }
        }

        private void OnRestartedAfterCrashed(object sender, FISProxy e)
        {
            Logger.WriteLineError($"OnRestartedAfterCrashed Invoke");
            FISProxy = e;
            if (FISProxy == null)
            {
                throw new Exception("OnRestartedAfterCrashed Failed, The FISProxy is null");
            }
            FISProxy.FeatureUpdated += OnFeatureUpdated;
            FISConnect = FISProxy.GetFISConnect();
            FISConnect.StatusChanged += OnStatusChanged;
            FISVid = FISProxy.GetFISVid();
            MessageBox.Show("FIS Exe Restarted After Crashed", "提示", MessageBoxButton.OK, MessageBoxImage.Information);
            if (_tempConnectStatus)
            {
                Connect();
            }
        }

        internal void Connect()
        {
            if (IsConnected)
            {
                return;
            }
            _connectionInfo = new FISConnectionInfo(FIS.FISSettingsInfo.CurrentServer, new FISAccountInfo("", "", false), "", new FISFeatureSettings
            {
                RemedicalEnabled = true,
                LiveVideoEnabled = FIS.FISSettingsInfo.LiveVideoEnabled,
                AfterSalesEnabled = true,
            });
            if (FISConnect == null)
            {
                FISLogInfoNotificated?.Invoke(this, new FISLogEventArgs(FISDeviceLogCategory.Error, "FISConnect is Null"));
                return;
            }
            DeviceStatus = FISConnect.Connect(_connectionInfo);
        }

        internal void Disconnect()
        {
            if (!IsConnected)
            {
                return;
            }
            FISConnect.Disconnect();
        }
    }
}