using FEIApiControl;
using OTSDataType;
using System;
using System.Collections.Generic;
using System.Configuration;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace OTSModelSharp.ServiceInterface
{
    public class SemController : ISemController
    {
        public static OTSCLRINTERFACE.COTSControlFunExport hw=null;
        public static APIClass ApiClass = null;
        private static SemController sem = null;
        private static bool isFEI = false;
        public static SemController GetSEMController()
        {
            if (FileHelper.GetXMLInformations("SemControllerName") == "FEI")
            {
                isFEI = true;
            }

            if (sem == null)
            {
                sem = new SemController();
            }

            return sem;
        }
        private SemController()
        {
            if (isFEI)
            {
                ApiClass = new APIClass();
            }
            else
            {
                hw = OTSCLRINTERFACE.COTSControlFunExport.GetControllerInstance();
            }
        }
       
        public bool Connect()
        {
            if (isFEI)
            {
                string FEIIP = FileHelper.GetXMLInformations("FEIIP");
                string FEIPORT = FileHelper.GetXMLInformations("FEIPORT");
                if (FEIIP == "" || FEIPORT == "")
                {
                    NLog.LogManager.GetCurrentClassLogger().Error("FEI电镜端口配置为空！");
                    return false;
                }

                if (ApiClass.isConnect())
                {
                    return true;
                }

                return ApiClass.Connect(FEIIP, FEIPORT);
            }
            else
            {
                if (!hw.Init())
                {
                    return false;
                }
                if (hw.IsConnected())
                {
                    return true;
                }

                return hw.ConncetSem();
            }
        }
        public bool IsConnected()
        {
            if (isFEI)
            {
                return ApiClass.isConnect();
            }
            else
            {
                return hw.IsConnected();
            }
        }
        public bool DisConnect()
        {
            if (isFEI)
            {
                return ApiClass.DisConnect();
            }
            else
            {
                if (hw.IsConnected())
                {
                    return hw.DisconnectSem();
                }

                return true;
            }
        }
        public bool GetSEMDataGnrFromHw(ref CSEMDataGnr SemDataGnr)
        {
            double kv = 0, brightness = 0, contrast = 0;
            if (isFEI)
            {
                kv = ApiClass.GetHightVoltage() / 1000;
                brightness = ApiClass.GetDetectorBrightness();
                contrast = ApiClass.GetDetectorContrast();
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }

                hw.GetSemHighTension(ref kv);
                hw.GetSemBrightness(ref brightness);
                hw.GetSemContrast(ref contrast);
            }

            SemDataGnr.SetValue(kv, brightness, contrast);
            return true;
        }
        public bool GetMagnification(ref double a_dMagnification)
        {
            if (isFEI)
            {
                return ApiClass.GetMagnification(ref a_dMagnification);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.GetSemMagnification(ref a_dMagnification);
            }
        }

        public bool GetScanFieldSize(ref double dScanFieldSizeX, ref double dScanFieldSizeY)
        {
            if (isFEI)
            {
                return ApiClass.GetSemScanFieldSize(ref dScanFieldSizeX, ref dScanFieldSizeY);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.GetSemScanFieldSize(ref dScanFieldSizeX, ref dScanFieldSizeY);
            }
        }

        public bool SetScanFieldSize100(double dScanFieldSizeX, double dScanFieldSizeY)
        {
            if (isFEI)
            {
                ApiClass.SetMagnification(100);
                return ApiClass.GetSemScanFieldSize(ref dScanFieldSizeX, ref dScanFieldSizeY);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                Size size = new Size();
                hw.SetSemScanField100(size);
                dScanFieldSizeX = size.Width;
                dScanFieldSizeY = size.Height;
                return true;
            }
        }

        public bool GetScanFieldSize100(ref double dScanFieldSizeX, ref double dScanFieldSizeY)
        {
            if (isFEI)
            {
                ApiClass.SetMagnification(100);
                return ApiClass.GetSemScanFieldSize(ref dScanFieldSizeX, ref dScanFieldSizeY);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                Size size = hw.GetSemScanField100();
                dScanFieldSizeX = size.Width;
                dScanFieldSizeY = size.Height;
                return true;
            }
        }

        public bool GetSemPositionXY(ref double a_dPositionX, ref double a_dPositionY, ref double a_dPositionR)
        {
            if (isFEI)
            {
                double a_dPositionZ = 0;
                double a_dPositionT = 0;
                return ApiClass.GetSemPositionXYZRT(ref a_dPositionX, ref a_dPositionY, ref a_dPositionZ, ref a_dPositionR, ref a_dPositionT);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.GetSemPositionXY(ref a_dPositionX, ref a_dPositionY, ref a_dPositionR);
            }
        }

      

        public bool GetWorkingDistance(ref double a_distance)
        {
            if (isFEI)
            {
                return ApiClass.GetWorkingDistance(ref a_distance);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
               
                return hw.GetSemWorkingDistance(ref a_distance);
            }
        }

        public bool MoveSEMToPoint(double a_dPositionX, double a_dPositionY, double a_dRotation)
        {
            if (isFEI)
            {
                return ApiClass.SetSemPositionXYR(a_dPositionX, a_dPositionY, a_dRotation);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.MoveSEMToPoint(a_dPositionX, a_dPositionY, a_dRotation);
            }
        }

        public bool MoveSEMToPoint(double a_dPositionX, double a_dPositionY)
        {
            if (isFEI)
            {
                return ApiClass.SetSemPositionXY(a_dPositionX, a_dPositionY);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.MoveSEMToPoint(a_dPositionX, a_dPositionY);
            }
        }

        public bool SetMagnification(double a_dMagnification)
        {
            if (isFEI)
            {
                return ApiClass.SetMagnification(a_dMagnification);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                NLog.LogManager.GetCurrentClassLogger().Warn("Set Magnification:" + a_dMagnification.ToString("F2"));
                hw.SetSemMagnification(a_dMagnification);
                return true;
            }
        }

        public bool SetScanExternal(bool b)
        {
            if (isFEI)
            {
                return ApiClass.SetSemScanExternal(b);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.SetSemScanExternal(b);
            }
        }

        public bool SetWorkingDistance(double a_distance)
        {
            if (isFEI)
            {
                return ApiClass.SetWorkingDistance(a_distance);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.SetSemWorkingDistance(a_distance);
            }
            System.Threading.Thread.Sleep(1000);
        }

        public bool GetSemBrightness(ref double a_dBrightness)
        {
            if (isFEI)
            {
                a_dBrightness = ApiClass.GetDetectorBrightness();
                return true;
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.GetSemBrightness(ref a_dBrightness);
            }
        }

        public bool SetSemBrightness(double a_dBrightness)
        {
            if (isFEI)
            {
                return ApiClass.SetDetectorBrightness(a_dBrightness);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.SetSemBrightness(a_dBrightness);
            }
        }

        public bool GetSemContrast(ref double a_dContrast)
        {
            if (isFEI)
            {
                a_dContrast = ApiClass.GetDetectorContrast();
                return true;
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.GetSemContrast(ref a_dContrast);
            }
        }

        public bool SetSemContrast(double a_dContrast)
        {
            if (isFEI)
            {
                return ApiClass.SetDetectorContrast(a_dContrast);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.SetSemContrast(a_dContrast);
            }
        }

        public bool GetSemHighTension(ref double a_dKV)
        {
            if (isFEI)
            {
                a_dKV = ApiClass.GetHightVoltage() / 1000;
                return true;
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.GetSemHighTension(ref a_dKV);
            }
        }

        public bool SetSemHighTension(double a_dKV)
        {
            if (isFEI)
            {
                return ApiClass.SetHightVoltage(a_dKV);
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.SetSemHighTension(a_dKV);
            }
        }

        public bool SetSemBeamCurrent(bool a_dKV)
        {
            if (isFEI)
            {
                if (a_dKV)
                {
                    return ApiClass.SetBeamStateOn();
                }
                else
                {
                    return ApiClass.SetBeamStateOff();
                }
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.SetSemBeamCurrent(a_dKV);
            }
        }

        public bool SetSemBeamBlank(bool a_dKV)
        {
            if (isFEI)
            {
                if (a_dKV)
                {
                    return ApiClass.SetBeamStateOn();
                }
                else
                {
                    return ApiClass.SetBeamStateOff();
                }
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }
                return hw.SetSemBeamBlank(a_dKV);
            }
        }

        public bool GetSemBeamBlank(ref int a_nBeamBlank)
        {
            if (isFEI)
            {
                if (ApiClass.GetIsBlanked())
                {
                    a_nBeamBlank = 1;
                }
                else
                {
                    a_nBeamBlank = 0;
                }
                return true;
            }
            else
            {
                if (!hw.IsConnected())
                {
                    return false;
                }

                return hw.GetSemBeamBlank(ref a_nBeamBlank);
            }
        }

        public bool StopXrayAcquisition()
        {
            if (isFEI)
            {
                return ApiClass.DisConnect();
            }
            else
            {
                if (hw.IsConnected())
                {
                    return hw.StopXrayAcquisition();
                }

                return true;
            }
        }

        public OTSCLRINTERFACE.COTSControlFunExport GetHardwareInterface()
        {
            if (!hw.IsConnected())
            {
                return null;
            }
            return hw;
        }
    }
}