namespace OINA.Extender.WPF.Testharness
{
    using System.Collections.Generic;
    using System.Collections.ObjectModel;
    using System.IO;
    using OINA.Extender;
    using OINA.Extender.Acquisition.Ed;
    using OINA.Extender.Acquisition.Image;
    using OINA.Extender.Acquisition.Quant;
    using OINA.Extender.DetectorControl;
    using OINA.Extender.MonitorControl;
    using OINA.Extender.Processing;
    using OINA.Extender.Processing.Ed;
    using OINA.Extender.Processing.Quant;

    /// <summary>
    /// OI Helper Static Class
    /// </summary>
    public static class OIHelper
    {
        /// <summary>
        /// IEdSpectrumAcquisitionController object
        /// </summary>
        private static IEdSpectrumAcquisitionController edSpectrumController;

        /// <summary>
        /// Controller for quant calibration
        /// </summary>
        private static IQuantCalibrationController quantCalibrationController;

        /// <summary>
        /// Settings for quant calibration
        /// </summary>
        private static IQuantCalibrationSettings quantCalibrationSettings;

        /// <summary>
        /// IEdSpectrumSettings object
        /// </summary>
        private static IEdSpectrumSettings edSpectrumSettings;

        /// <summary>
        /// IEdSpectrumProcessing object
        /// </summary>
        private static IEdSpectrumProcessing edSpectrumProcessing;

        /// <summary>
        /// IAutoIdSettings object
        /// </summary>
        private static IAutoIdSettings edAutoIdSettings;

        /// <summary>
        /// Semquantsettings object
        /// </summary>
        private static ISEMQuantSettings semQuantSettings;

        /// <summary>
        /// IMonitoringController object
        /// </summary>
        private static IMonitoringController monitoringController;

        /// <summary>
        /// IImageAcquisitionController object
        /// </summary>
        private static IImageAcquisitionController imageController;

        /// <summary>
        /// IImageSettings object
        /// </summary>
        private static IImageAcquisitionSettings imageAcquisitionSettings;

        /// <summary>
        /// IEdDetectorControl object
        /// </summary>
        private static IEdDetectorControl edDetectorControl;

        /// <summary>
        /// Gets EdSpectrum Acquisition Controller
        /// </summary>
        public static IEdSpectrumAcquisitionController EdSpectrumAcquisitionController
        {
            get
            {
                if (edSpectrumController == null)
                {
                    edSpectrumController = AcquireFactory.CreateEdSpectrumServer();
                }

                return edSpectrumController;
            }
        }

        /// <summary>
        /// Gets QuantCalibrationController Controller
        /// </summary>
        public static IQuantCalibrationController QuantCalibrationController
        {
            get
            {
                if (quantCalibrationController == null)
                {
                    quantCalibrationController = AcquireFactory.CreateQuantCalibrationController();
                }

                return quantCalibrationController;
            }
        }

        /// <summary>
        /// Gets QuantCalibrationSettings Settings
        /// </summary>
        public static IQuantCalibrationSettings QuantCalibrationSettings
        {
            get
            {
                if (quantCalibrationSettings == null)
                {
                    quantCalibrationSettings = AcquireFactory.CreateQuantCalibrationSettings();
                }

                return quantCalibrationSettings;
            }
        }

        /// <summary>
        /// Gets EdSpectrum Settings
        /// </summary>
        public static IEdSpectrumSettings EdSpectrumSettings
        {
            get
            {
                if (edSpectrumSettings == null)
                {
                    edSpectrumSettings = AcquireFactory.CreateEdSpectrumSettings();
                }

                return edSpectrumSettings;
            }
        }

        /// <summary>
        /// Gets EdSpectrum Processing
        /// </summary>
        public static IEdSpectrumProcessing EdSpectrumProcessing
        {
            get
            {
                if (edSpectrumProcessing == null)
                {
                    edSpectrumProcessing = ProcessingFactory.CreateSpectrumProcessing();
                }

                return edSpectrumProcessing;
            }
        }

        /// <summary>
        /// Gets AutoId Settings
        /// </summary>
        public static IAutoIdSettings AutoIdSettings
        {
            get
            {
                if (edAutoIdSettings == null)
                {
                    edAutoIdSettings = ProcessingFactory.CreateAutoIdSettings();
                }

                return edAutoIdSettings;
            }
        }

        /// <summary>
        /// Gets SEM Quant Settings
        /// </summary>
        public static ISEMQuantSettings SEMQuantSettings
        {
            get
            {
                if (semQuantSettings == null)
                {
                    semQuantSettings = ProcessingFactory.CreateSEMQuantSettings();
                }

                return semQuantSettings;
            }
        }

        /// <summary>
        /// Gets Monitoring Controller
        /// </summary>
        public static IMonitoringController MonitoringController
        {
            get
            {
                if (monitoringController == null)
                {
                    monitoringController = AcquireFactory.CreateMonitorControl();
                }

                return monitoringController;
            }
        }

        /// <summary>
        /// Gets Image Acquisition Controller
        /// </summary>
        public static IImageAcquisitionController ImageAcquisitionController
        {
            get
            {
                if (imageController == null)
                {
                    imageController = AcquireFactory.CreateImageServer();
                }

                return imageController;
            }
        }

        /// <summary>
        /// Gets Image Acquisition Settings
        /// </summary>
        public static IImageAcquisitionSettings ImageSettings
        {
            get
            {
                if (imageAcquisitionSettings == null)
                {
                    imageAcquisitionSettings = AcquireFactory.CreateImageSettings();
                }

                return imageAcquisitionSettings;
            }
        }

        /// <summary>
        /// Gets Image Acquisition Settings
        /// </summary>
        public static IEdDetectorControl EDDetectorControl
        {
            get
            {
                if (edDetectorControl == null)
                {
                    edDetectorControl = AcquireFactory.CreateEdDetectorControl()[0];
                }

                return edDetectorControl;
            }
        }

        /// <summary>
        /// Read a file to a byte array
        /// </summary>
        /// <param name="filePath">file path</param>
        /// <returns>byte[] data</returns>
        public static byte[] FileToByteArray(string filePath)
        {
            if (!File.Exists(filePath))
            {
                throw new System.InvalidOperationException("File does not exists!");
            }

            FileStream fs = File.OpenRead(filePath);
            {
                byte[] data = new byte[fs.Length];
                fs.Read(data, 0, (int)fs.Length);
                fs.Close();
                return data;
            }
        }

        /// <summary>
        /// Save a byte array to a file
        /// </summary>
        /// <param name="filePath">file path</param>
        /// <param name="data">data</param>
        public static void ByteArrayToFile(string filePath, byte[] data)
        {
            // If file already exists, delete it.
            if (File.Exists(filePath))
            {
                File.Delete(filePath);
            }

            using (FileStream fs = File.Create(filePath))
            {
                fs.Write(data, 0, data.Length);
            }
        }

        /// <summary>
        /// Gets a collection of scan sizes that are allowed by the pixel sizes of the ScanCapabilities.
        /// </summary>
        /// <param name="minimumPixelSize">The Minimum Pixel Size</param>
        /// <param name="maximumPixelSize">The Maximum Pixel Size</param>
        /// <returns>An ICollection[double] of the scan sizes</returns>
        internal static ICollection<double> GetScanSizes(double minimumPixelSize, double maximumPixelSize)
        {
            var scanSizesCollection = new Collection<double>();

            int minScanSize = (int)(1d / maximumPixelSize),
                maxScanSize = (int)(1d / minimumPixelSize);

            int scanSize = minScanSize;

            while (scanSize <= maxScanSize)
            {
                scanSizesCollection.Add(scanSize);
                scanSize *= 2;
            }

            return scanSizesCollection;
        }
    }
}