using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Runtime.InteropServices;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.VisualStyles;
using System.ComponentModel;
using System.Drawing.Imaging;
using System.Globalization;
using static System.Net.Mime.MediaTypeNames;
using System.Diagnostics;
using System.Net.NetworkInformation;
using System.Net;


namespace UTIL
{
    public static class ASMBL
    {
        #region Методы доступа к атрибутам сборки

        public static string AssemblyTitle
        {
            get
            {
                object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false);
                if (attributes.Length > 0)
                {
                    AssemblyTitleAttribute titleAttribute = (AssemblyTitleAttribute)attributes[0];
                    if (titleAttribute.Title != "")
                    {
                        return titleAttribute.Title;
                    }
                }
                return System.IO.Path.GetFileNameWithoutExtension(Assembly.GetExecutingAssembly().CodeBase);
            }
        }

        public static string AssemblyVersion
        {
            get
            {
                return Assembly.GetExecutingAssembly().GetName().Version.ToString();
            }
        }

        public static string AssemblyDescription
        {
            get
            {
                object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false);
                if (attributes.Length == 0)
                {
                    return "";
                }
                return ((AssemblyDescriptionAttribute)attributes[0]).Description;
            }
        }

        public static string AssemblyProduct
        {
            get
            {
                object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false);
                if (attributes.Length == 0)
                {
                    return "";
                }
#if DEBUG
                return ((AssemblyProductAttribute)attributes[0]).Product + " Debug version";
#else
				return ((AssemblyProductAttribute)attributes[0]).Product + " Release version";
#endif
            }
        }

        public static string AssemblyCopyright
        {
            get
            {
                object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false);
                if (attributes.Length == 0)
                {
                    return "";
                }
                return ((AssemblyCopyrightAttribute)attributes[0]).Copyright;
            }
        }

        public static string AssemblyCompany
        {
            get
            {
                object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false);
                if (attributes.Length == 0)
                {
                    return "";
                }
                return ((AssemblyCompanyAttribute)attributes[0]).Company;
            }
        }
        public static string AssemblyConfiguration
        {
            get
            {
#if DEBUG
                return "Debug version";
#else
				return "Release version";
#endif
            }
        }
        public static string[] AssemblyConf
        {
            get
            {
                string[] s = new string[11];

                object[] attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyConfigurationAttribute), false);
#if DEBUG
                s[0] = "Debug version";
#else
				s[0] = "Release version";
#endif
                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyAlgorithmIdAttribute), false);
                if (attributes.Length == 0)
                    s[1] = "AssemblyAlgorithmId = ";
                else
                    s[1] = "AssemblyAlgorithmId = " + ((AssemblyAlgorithmIdAttribute)attributes[0]).AlgorithmId;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCompanyAttribute), false);
                if (attributes.Length == 0)
                    s[2] = "AssemblyCompany = ";
                else
                    s[2] = "AssemblyCompany = " + ((AssemblyCompanyAttribute)attributes[0]).Company;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyCopyrightAttribute), false);
                if (attributes.Length == 0)
                    s[3] = "AssemblyCopyright = ";
                else
                    s[3] = "AssemblyCopyright = " + ((AssemblyCopyrightAttribute)attributes[0]).Copyright;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyDescriptionAttribute), false);
                if (attributes.Length == 0)
                    s[4] = "AssemblyDescription = ";
                else
                    s[4] = "AssemblyDescription = " + ((AssemblyDescriptionAttribute)attributes[0]).Description;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyFileVersionAttribute), false);
                if (attributes.Length == 0)
                    s[5] = "AssemblyFileVersion = ";
                else
                    s[5] = "AssemblyFileVersion = " + ((AssemblyFileVersionAttribute)attributes[0]).Version;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false);
                if (attributes.Length == 0)
                    s[6] = "AssemblyInformationalVersion = ";
                else
                    s[6] = "AssemblyInformationalVersion = " + ((AssemblyInformationalVersionAttribute)attributes[0]).InformationalVersion;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyProductAttribute), false);
                if (attributes.Length == 0)
                    s[7] = "AssemblyProduct = ";
                else
                    s[7] = "AssemblyProduct = " + ((AssemblyProductAttribute)attributes[0]).Product;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTitleAttribute), false);
                if (attributes.Length == 0)
                    s[8] = "AssemblyTitle = ";
                else
                    s[8] = "AssemblyTitle = " + ((AssemblyTitleAttribute)attributes[0]).Title;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyTrademarkAttribute), false);
                if (attributes.Length == 0)
                    s[9] = "AssemblyTrademark = ";
                else
                    s[9] = "AssemblyTrademark = " + ((AssemblyTrademarkAttribute)attributes[0]).Trademark;

                attributes = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyVersionAttribute), false);
                if (attributes.Length == 0)
                    s[10] = "AssemblyVersion = ";
                else
                    s[10] = "AssemblyVersion = " + ((AssemblyVersionAttribute)attributes[0]).Version;

                return s;
            }
        }
        #endregion
    }

    public class IniFile
    {
        [DllImport("kernel32.dll")]
        private extern static int GetPrivateProfileString(String AppName, String KeyName, String Default, StringBuilder ReturnedString, UInt32 Size, String FileName);
        [DllImport("kernel32.dll")]
        private extern static int WritePrivateProfileString(String AppName, String KeyName, String Str, String FileName);
        public IniFile(string filename)
        {
            IniFileName = filename;
        }
        public String IniFileName
        {
            get;
            set;
        }
        public String _GetString(String section, String key)
        {
            StringBuilder s1 = new StringBuilder(128);
            GetPrivateProfileString(section, key, "", s1, 128, IniFileName);
            return s1.ToString();
        }
        public Int64 _GetInt(String section, String key)
        {
            StringBuilder s1 = new StringBuilder(100);
            GetPrivateProfileString(section, key, "", s1, 100, IniFileName);
            return Int64.Parse(s1.ToString());
        }
        public Boolean _GetBool(String section, String key)
        {
            StringBuilder s1 = new StringBuilder(100);
            GetPrivateProfileString(section, key, "", s1, 100, IniFileName);
            return Boolean.Parse(s1.ToString());
        }
        public Double _GetDouble(String section, String key)
        {
            StringBuilder s1 = new StringBuilder(100);
            GetPrivateProfileString(section, key, "", s1, 100, IniFileName);
            return Double.Parse(s1.ToString());
        }
        public void _SetString(String section, String key, String val)
        {
            WritePrivateProfileString(section, key, val, IniFileName);
        }
        public void _SetInt(String section, String key, Int64 val)
        {
            WritePrivateProfileString(section, key, val.ToString(), IniFileName);
        }
        public void _SetDouble(String section, String key, Double val)
        {
            WritePrivateProfileString(section, key, val.ToString(), IniFileName);
        }
        public void _SetBool(String section, String key, Boolean val)
        {
            WritePrivateProfileString(section, key, val.ToString(), IniFileName);
        }
    }

    public static class S2B
    {
        #region Загрузка/выгрузка данных в структуру
        //public static T BuffToStruct<T>(byte[] arr)
        //{
        //    GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned);
        //    IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0);
        //    T ret = (T)Marshal.PtrToStructure(ptr, typeof(T));
        //    gch.Free();
        //    return default(T);
        //}
        public static T BuffToStruct<T>(byte[] arr)
        {
            GCHandle handle = GCHandle.Alloc(arr, GCHandleType.Pinned);
            T stuff = (T)Marshal.PtrToStructure(
                handle.AddrOfPinnedObject(), typeof(T));
            handle.Free();
            return stuff;
        }
        public static T BuffToClass<T>(byte[] arr)
        {
            GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned);
            IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0);
            T ret = (T)Marshal.PtrToStructure(ptr, typeof(T));
            gch.Free();
            return default(T);
        }
        public static byte[] StructToBuff<T>(T value) where T : struct
        {
            byte[] arr = new byte[Marshal.SizeOf(value)]; // создать массив
            GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned); // зафиксировать в памяти
            IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0); // и взять его адрес
            Marshal.StructureToPtr(value, ptr, true); // копировать в массив
            gch.Free(); // снять фиксацию
            return arr;
        }
        public static byte[] ClassToBuff<T>(T value) where T : class
        {
            byte[] arr = new byte[Marshal.SizeOf(value)]; // создать массив
            GCHandle gch = GCHandle.Alloc(arr, GCHandleType.Pinned); // зафиксировать в памяти
            IntPtr ptr = Marshal.UnsafeAddrOfPinnedArrayElement(arr, 0); // и взять его адрес
            Marshal.StructureToPtr(value, ptr, true); // копировать в массив
            gch.Free(); // снять фиксацию
            return arr;
        }
        #endregion
    }

    public static class RichTextBoxExtensions
    {
        public static void AppendText(this RichTextBox box, string text, Color color)
        {
            if (box.InvokeRequired)
            {
                box.Invoke((MethodInvoker)(delegate
                {
                    box.SelectionStart = box.TextLength;
                    box.SelectionLength = 0;
                    box.SelectionColor = color;
                    box.AppendText(text);
                    box.SelectionColor = box.ForeColor;
                    box.ScrollToCaret();
                }));
            }
            else
            {
                box.SelectionStart = box.TextLength;
                box.SelectionLength = 0;
                box.SelectionColor = color;
                box.AppendText(text);
                box.SelectionColor = box.ForeColor;
                box.ScrollToCaret();
            }
        }
        public static void AppendText(this RichTextBox box, string text, Color bgcolor, Color fgcolor)
        {
            if (box.InvokeRequired)
            {
                box.Invoke((MethodInvoker)(delegate
                {
                    box.SelectionStart = box.TextLength;
                    box.SelectionLength = 0;
                    box.SelectionColor = fgcolor;
                    box.SelectionBackColor = bgcolor;
                    box.AppendText(text);
                    box.SelectionColor = box.ForeColor;
                    box.SelectionBackColor = box.BackColor;
                    box.ScrollToCaret();
                }));
            }
            else
            {
                box.SelectionStart = box.TextLength;
                box.SelectionLength = 0;
                box.SelectionColor = fgcolor;
                box.SelectionBackColor = bgcolor;
                box.AppendText(text);
                box.SelectionColor = box.ForeColor;
                box.SelectionBackColor = box.BackColor;
                box.ScrollToCaret();
            }
        }
    }

    public class GKalman
    {
        double _err_measure = 0.0F;
        double _err_estimate = 0.0F;
        double _q = 0.0F;
        double _last_estimate = 0.0F;
        public GKalman(double mea_e, double est_e, double q)
        {
            setParameters(mea_e, est_e, q);
        }

        // разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
        public GKalman(double mea_e, double q)
        {
            setParameters(mea_e, mea_e, q);
        }

        // разброс измерения, разброс оценки, скорость изменения значений
        public void setParameters(double mea_e, double est_e, double q)
        {
            _err_measure = mea_e;
            _err_estimate = est_e;
            _q = q;
        }

        // разброс измерения, скорость изменения значений (разброс измерения принимается равным разбросу оценки)
        public void setParameters(double mea_e, double q)
        {
            setParameters(mea_e, mea_e, q);
        }

        // возвращает фильтрованное значение
        public double filtered(double value)
        {
            double _kalman_gain, _current_estimate;
            _kalman_gain = _err_estimate / (_err_estimate + _err_measure);
            _current_estimate = _last_estimate + _kalman_gain * (value - _last_estimate);
            _err_estimate = (1.0 - _kalman_gain) * _err_estimate + Math.Abs(_last_estimate - _current_estimate) * _q;
            _last_estimate = _current_estimate;
            return (double)_current_estimate;
        }
    }

    public unsafe class UnsafeBitmap
    {
        Bitmap bitmap;
        // three elements used for MakeGreyUnsafe
        int width;
        BitmapData bitmapData = null;
        Byte* pBase = null;
        public UnsafeBitmap(Bitmap bitmap)
        {
            this.bitmap = new Bitmap(bitmap);
        }
        public UnsafeBitmap(int width, int height)
        {
            this.bitmap = new Bitmap(width, height, PixelFormat.Format24bppRgb);
        }
        public void Dispose()
        {
            bitmap.Dispose();
        }
        public Bitmap Bitmap
        {
            get
            {
                return (bitmap);
            }
        }
        private Point PixelSize
        {
            get
            {
                GraphicsUnit unit = GraphicsUnit.Pixel;
                RectangleF bounds = bitmap.GetBounds(ref unit);

                return new Point((int)bounds.Width, (int)bounds.Height);
            }
        }
        public void LockBitmap()
        {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF boundsF = bitmap.GetBounds(ref unit);
            Rectangle bounds = new Rectangle((int)boundsF.X,
            (int)boundsF.Y,
            (int)boundsF.Width,
            (int)boundsF.Height);

            // Figure out the number of bytes in a row
            // This is rounded up to be a multiple of 4
            // bytes, since a scan line in an image must always be a multiple of 4 bytes
            // in length. 
            width = (int)boundsF.Width * sizeof(PixelData);
            if (width % 4 != 0)
            {
                width = 4 * (width / 4 + 1);
            }
            bitmapData =
            bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            pBase = (Byte*)bitmapData.Scan0.ToPointer();
        }
        public PixelData GetPixel(int x, int y)
        {
            PixelData returnValue = *PixelAt(x, y);
            return returnValue;
        }
        public void SetPixel(int x, int y, PixelData colour)
        {
            PixelData* pixel = PixelAt(x, y);
            *pixel = colour;
        }
        public void UnlockBitmap()
        {
            bitmap.UnlockBits(bitmapData);
            bitmapData = null;
            pBase = null;
        }
        public PixelData* PixelAt(int x, int y)
        {
            return (PixelData*)(pBase + y * width + x * sizeof(PixelData));
        }
    }
    public struct PixelData
    {
        public byte blue;
        public byte green;
        public byte red;
    }
    public static class Util
    {
        public static String Val(Object value)
        {
            //            Console.WriteLine(value.GetType());
            //            String tmp = value.GetType().ToString().Split(new Char[] { '.' })[1];
            String tmp;
            tmp = value.GetType().ToString();
            Console.WriteLine(tmp);
            tmp = value.GetType().ToString().Split(new Char[] { '.' })[1];
            Console.WriteLine(tmp);
            switch (tmp)
            {
                case "Double":
                case "Single":
                case "Decimal":
//                    return Math.Round(Convert.ToDouble(value), 2).ToString("+0.00;-0.00;+0.00");
                case "UInt64":
                case "UInt32":
                case "UInt16":
                case "Byte":
//                    return value.ToString();
//                    return $"{value:+0;+0;+0}";
                case "Int64":
                case "Int32":
                case "Int16":
                case "SByte":
//                    return $"{value:+0;-0;+0}";
//                    return value.ToString();
                case "String":
//                    return $"{value}";
//                    return value.ToString();
                case "Hex":
//                    return $"{value}";
//                    return value.ToString();
                default:
                    break;
            }
            return "";
        }
        public static T minmax<T>(T min, T max, T val)
        {
            dynamic dmin = min;
            dynamic dmax = max;
            dynamic dval = val;
            if (dval <= dmin)
                return dmin;
            if (dval > dmax)
                return dmax;
            return dval;
        }
        public struct Hex<T>
        {
            private T _Value;
            public static implicit operator Hex<T>(T value)
            {
                return new Hex<T> { _Value = value };
            }
            public static implicit operator T(Hex<T> value)
            {
                return value._Value;
            }
            public override string ToString()
            {
                if (_Value.GetType() == typeof(UInt64))
                    return $"{_Value:X016}";
                if (_Value.GetType() == typeof(UInt32))
                    return $"{_Value:X08}";
                if (_Value.GetType() == typeof(UInt16))
                    return $"{_Value:X04}";
                if (_Value.GetType() == typeof(Byte))
                    return $"{_Value:X02}";
                return _Value.ToString();
            }
        }
        public struct Hex0x<T>
        {
            private T _Value;
            private CultureInfo ci;// = new CultureInfo("ru-Ru");
            public static implicit operator Hex0x<T>(T value)
            {
                return new Hex0x<T> { _Value = value };
            }
            public static implicit operator T(Hex0x<T> value)
            {
                return value._Value;
            }
            public override string ToString()
            {
                if (_Value.GetType() == typeof(UInt64))
                    return $"0x{_Value:X016}";
                if (_Value.GetType() == typeof(UInt32))
                    return $"0x{_Value:X08}";
                if (_Value.GetType() == typeof(UInt16))
                    return $"0x{_Value:X04}";
                if (_Value.GetType() == typeof(Byte))
                    return $"0x{_Value:X02}";
                return _Value.ToString();
            }
        }
        public static String printtime(Boolean ms)
        {
            if (ms == true)
                return DateTime.Now.ToString("HH:mm:ss:fff ");
            else
                return DateTime.Now.ToString("HH:mm:ss ");
        }
        public static String printdatetime(Boolean ms)
        {
            if (ms == true)
                return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:fff ");
            else
                return DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss ");
        }
        private const int EM_SETTABSTOPS = 0x00CB;
        [DllImport("User32.dll", CharSet = CharSet.Auto)]
        public static extern IntPtr SendMessage(IntPtr h, int msg, int wParam, int[] lParam);
        public static void SetTabWidth(TextBox textbox, int tabWidth)
        {
            Graphics graphics = textbox.CreateGraphics();
            var characterWidth = (int)graphics.MeasureString("M", textbox.Font).Width;
            SendMessage
                (textbox.Handle
                , EM_SETTABSTOPS
                , 1
                , new int[] { tabWidth * characterWidth }
                );
        }
        public static String Format<T>(T num, UInt16 chars, Boolean sign)
        {
            String tmp = num.GetType().ToString().Split(new Char[] { '.' })[1];
            String a = "";
            switch (tmp)
            {
                case "Double":
                case "Single":
                case "Decimal":
                    if (!sign)
                        a = Math.Round(Convert.ToDouble(num), 0).ToString().PadLeft(chars, ' ');
                    else
                        a = Math.Round(Convert.ToDouble(num), 0).ToString("+0;-#").PadLeft(chars, ' ');
                    return a;
                case "UInt64":
                case "UInt32":
                case "UInt16":
                case "Byte":
                case "Int64":
                case "Int32":
                case "Int16":
                case "SByte":
                    if (!sign)
                        a = Convert.ToInt64(num).ToString().PadLeft(chars, ' ');
                    else
                        a = Convert.ToInt64(num).ToString("+0;-#").PadLeft(chars, ' '); 
                    return a;
                default:
                    return num.ToString();
            }
        }
        public static String Format<T>(T num, UInt16 chars, Boolean sign, UInt16 round)
        {
            String tmp = num.GetType().ToString().Split(new Char[] { '.' })[1];
            String a = "";
            switch (tmp)
            {
                case "Double":
                case "Single":
                case "Decimal":
                    if (!sign)
                        a = Math.Round(Convert.ToDouble(num), round).ToString().PadLeft(chars, ' ');
                    else
                        a = Math.Round(Convert.ToDouble(num), round).ToString("+0;-#").PadLeft(chars, ' ');
                    return a;
                case "UInt64":
                case "UInt32":
                case "UInt16":
                case "Byte":
                case "Int64":
                case "Int32":
                case "Int16":
                case "SByte":
                    if (!sign)
                        a = Convert.ToInt64(num).ToString().PadLeft(chars, ' ');
                    else
                        a = Convert.ToInt64(num).ToString("+0;-#").PadLeft(chars, ' ');
                    return a;
                default:
                    return num.ToString();
            }
        }
    }
    public class CircularBuffer<T>
    {
        T[] _buffer;
        Int32 _head;
        Int32 _tail;
        Int32 _length;
        Int32 _bufferSize;
        Int32 _pos;
        Object _lock = new object();
        public CircularBuffer(Int32 bufferSize)
        {
            _buffer = new T[bufferSize];
            _bufferSize = bufferSize;
            _head = bufferSize - 1;
            _tail = 0;
            _length = 0;
        }
        public Int32 Count
        {
            get { return _length; }
        }
        public Int32 Head
        {
            get { return _head; }
        }
        public Int32 Tail
        {
            get { return _tail; }
        }
        public bool IsEmpty
        {
            get { return _length == 0; }
        }
        public bool IsFull
        {
            get { return _length == _bufferSize; }
        }
        public bool IsNoData
        {
            get { return _tail + _pos >= _head; }
        }
        public T Dequeue()
        {
            if (IsEmpty) throw new InvalidOperationException("Queue exhausted");

            T dequeued = _buffer[_tail];
            _tail = NextPosition(_tail);
            _length--;
            return dequeued;
        }
        public T Peek(int pos)
        {
            _pos = pos;
            if (IsEmpty) throw new InvalidOperationException("Queue exhausted");
            if (_tail + pos > _head) throw new InvalidOperationException("End data");

            T dequeued = _buffer[_tail + pos];
            return dequeued;
        }
        public T Peek()
        {
            if (IsEmpty) throw new InvalidOperationException("Queue exhausted");
            if (_tail > _head) throw new InvalidOperationException("End data");
            T dequeued = _buffer[_tail];
            return dequeued;
        }
        private int NextPosition(int position)
        {
            return (position + 1) % _bufferSize;
        }
        public void Enqueue(T toAdd)
        {
            _head = NextPosition(_head);
            _buffer[_head] = toAdd;
            if (IsFull)
                _tail = NextPosition(_tail);
            else
                _length++;
        }
    }
    public class CircularBuffer2<T>
    {
        T[] _buffer;
        Int32 _head;
        Int32 _tail;
        Int32 _length;
        Int32 _bufferSize;
        Int32 _pos;
        Object _lock = new object();
        public CircularBuffer2(Int32 bufferSize)
        {
            _buffer = new T[bufferSize];
            _bufferSize = bufferSize;
            _head = bufferSize - 1;
            _tail = 0;
            _length = 0;
        }
        public T Dequeue()
        {
            T dequeued = _buffer[_tail];
            _tail = (_tail + 1) % _bufferSize;
            _length--;
            return dequeued;
        }
        public T Peek()
        {
            if (_length == 0) throw new InvalidOperationException("No data");
            return _buffer[_tail];
        }
        private int NextPosition(int position)
        {
            return (position + 1) % _bufferSize;
        }
        public void Enqueue(T toAdd)
        {
            _head = (_head + 1) % _bufferSize;
            _buffer[_head] = toAdd;
            if (_length == _bufferSize)
                _tail = (_tail + 1) % _bufferSize;
            else
                _length++;
        }
    }
    public class GMedian
    {
        UInt16[] bufUI16;
        Int16[] bufI16;
        UInt32[] bufUI32;
        Int32[] bufI32;
        Double[] bufd;
        Single[] buff;
        Byte _counter = 0;

        public GMedian(UInt16 num)
        {
            bufUI16 = new UInt16[num];
            bufI16 = new Int16[num];
            bufUI32 = new UInt32[num];
            bufI32 = new Int32[num];
            bufd = new Double[num];
            buff = new Single[num];
            _counter = 0;
        }
        /*
        #define SIZE 5
                int32_t bufferaz[SIZE];
                int32_t bufferum[SIZE];
                uint8_t _countaz = 0;
                uint8_t _countum = 0;
                int32_t filteredAZ(int32_t newVal)
                {
                    bufferaz[_countaz] = newVal;
                    if ((_countaz < SIZE - 1) && (bufferaz[_countaz] > bufferaz[_countaz + 1]))
                    {
                        for (int i = _countaz; i < SIZE - 1; i++)
                        {
                            if (bufferaz[i] > bufferaz[i + 1])
                            {
                                int32_t buff = bufferaz[i];
                                bufferaz[i] = bufferaz[i + 1];
                                bufferaz[i + 1] = buff;
                            }
                        }
                    }
                    else
                    {
                        if ((_countaz > 0) && (bufferaz[_countaz - 1] > bufferaz[_countaz]))
                        {
                            for (int i = _countaz; i > 0; i--)
                            {
                                if (bufferaz[i] < bufferaz[i - 1])
                                {
                                    int32_t buff = bufferaz[i];
                                    bufferaz[i] = bufferaz[i - 1];
                                    bufferaz[i - 1] = buff;
                                }
                            }
                        }
                    }
                    if (++_countaz >= SIZE) _countaz = 0;
                    return bufferaz[SIZE / 2];
                }
        */
    }
    public class GMedian<T> where T : IComparable<T>

    {
        private T[] buf;
        byte _count = 0;
        UInt16 _num = 0;

        public GMedian(UInt16 num)
        {
            buf = new T[num];
            _count = 0;
            _num = num;
        }
        public T filtered(T newVal)
        {
            buf[_count] = newVal;
            if ((_count < _num - 1) && (buf[_count].CompareTo(buf[_count + 1]) > 0))
            {
                for (int i = _count; i < _num - 1; i++)
                {
                    if (buf[i].CompareTo(buf[i + 1]) > 0)
                    {
                        T buff = buf[i];
                        buf[i] = buf[i + 1];
                        buf[i + 1] = buff;
                    }
                }
            }
            else
            {
                if ((_count > 0) && (buf[_count - 1].CompareTo(buf[_count])) > 0)
                {
                    for (int i = _count; i > 0; i--)
                    {
                        if (buf[i].CompareTo(buf[i - 1]) < 0)
                        {
                            T buff = buf[i];
                            buf[i] = buf[i - 1];
                            buf[i - 1] = buff;
                        }
                    }
                }
            }
            if (++_count >= _num) _count = 0;
            return buf[_num / 2];
        }

        /*
        #define SIZE 5
                int32_t bufferaz[SIZE];
                int32_t bufferum[SIZE];
                uint8_t _countaz = 0;
                uint8_t _countum = 0;
                int32_t filteredAZ(int32_t newVal)
                {
                    bufferaz[_countaz] = newVal;
                    if ((_countaz < SIZE - 1) && (bufferaz[_countaz] > bufferaz[_countaz + 1]))
                    {
                        for (int i = _countaz; i < SIZE - 1; i++)
                        {
                            if (bufferaz[i] > bufferaz[i + 1])
                            {
                                int32_t buff = bufferaz[i];
                                bufferaz[i] = bufferaz[i + 1];
                                bufferaz[i + 1] = buff;
                            }
                        }
                    }
                    else
                    {
                        if ((_countaz > 0) && (bufferaz[_countaz - 1] > bufferaz[_countaz]))
                        {
                            for (int i = _countaz; i > 0; i--)
                            {
                                if (bufferaz[i] < bufferaz[i - 1])
                                {
                                    int32_t buff = bufferaz[i];
                                    bufferaz[i] = bufferaz[i - 1];
                                    bufferaz[i - 1] = buff;
                                }
                            }
                        }
                    }
                    if (++_countaz >= SIZE) _countaz = 0;
                    return bufferaz[SIZE / 2];
                }
        */
    }
    public class SetNet
    {
        public void setIP(string caption, string ipaddress, Boolean dhcp)
        {
            //            SetIP(EthStatic, "/c netsh interface ip set address \"" + EthName + "\" static " + Properties.Settings.Default.EthIPac + " " + Properties.Settings.Default.Subnet + " " + Properties.Settings.Default.EthDnsac + " & netsh interface ip set dns \"" + EthName + "\" static " + Properties.Settings.Default.EthDnsac);
            String arg = "";
            if (!dhcp)
            {
                arg = $"/c netsh interface ipv4 set address \"{caption}\" static \"{ipaddress}\" \"255.0.0.0\"";
                //                arg = $"/c netsh interface ipv4 set address \"{caption}\" static \"{ipaddress}\" \"255.0.0.0\" \"192.168.1.2\" & netsh interface ipv4 set dns \"{caption}\" static  \"192.168.1.2\"";
                //                arg = $"/c netsh interface ip set address \"{caption}\" static \"{ipaddress}\" \"255.0.0.0\" \"192.168.1.2\" & netsh interface ip set dns \"{caption}\" static  \"192.168.1.2\"";
            }
            else
            {
                arg = $"/c netsh interface ipv4 set address \"{caption}\" dhcp & netsh interface ipv4 set dns \"{caption}\" dhcp";
                //                arg = $"/c netsh interface ip set address \"{caption}\" dhcp & netsh interface ip set dns \"{caption}\" dhcp";
            }

            try
            {
                ProcessStartInfo psi = new ProcessStartInfo("cmd.exe");
                psi.UseShellExecute = true;
                psi.WindowStyle = ProcessWindowStyle.Hidden;
                psi.Verb = "runas";
                psi.Arguments = arg;
                Process ps = Process.Start(psi);
                ps.WaitForExit();
                if (ps.HasExited)
                {
                    MessageBox.Show("Адрес изменен", "Информация", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        public List<String[]> getadapters()
        {
            List<String[]> adapters = new List<string[]>();
            String ip = "";
            String dns = "";
            String nic = "";
            String gw = "";
            String dhcp = "";
            String ipen = "";
            String sub = "";

            string[] NwDesc = { "TAP", "VMware", "Windows", "Virtual", "WAN", "Microsoft", "NDIS", "Bluetooth" };  // Adapter types (Description) to be ommited
            foreach (NetworkInterface ni in NetworkInterface.GetAllNetworkInterfaces())
            {
                if (ni.NetworkInterfaceType == NetworkInterfaceType.Ethernet && !NwDesc.Any(ni.Description.Contains))  // check for adapter type and its description
                {
                    nic = ni.Name;
                    Console.WriteLine($"Name: {nic} # Desc: {ni.Description} # Mac: {ni.GetPhysicalAddress().ToString()} # Status: {ni.OperationalStatus}");

                    if (ni.GetIPProperties().UnicastAddresses.Count == 0)
                        ip = "";
                    else
                    {
                        foreach (UnicastIPAddressInformation ips in ni.GetIPProperties().UnicastAddresses)
                        {
                            if (ips.Address.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                            {
                                ip = ips.Address.ToString();
                            }
                        }
                    }
                    if (ni.GetIPProperties().DnsAddresses.Count == 0)
                        dns = "";
                    else
                    {
                        foreach (IPAddress dnsAdress in ni.GetIPProperties().DnsAddresses)
                        {
                            if (dnsAdress.AddressFamily == System.Net.Sockets.AddressFamily.InterNetwork)
                            {
                                dns = dnsAdress.ToString();
                            }
                        }
                    }
                    if (ni.GetIPProperties().GatewayAddresses.Count == 0)
                        gw = "";
                    else
                    {
                        foreach (GatewayIPAddressInformation gwAdress in ni.GetIPProperties().GatewayAddresses)
                        {
                            gw = gwAdress.Address.ToString();
                        }
                    }
                    if (ni.GetIPProperties().DhcpServerAddresses.Count == 0)
                        dhcp = "";
                    else
                    {
                        foreach (IPAddress dhcpAdress in ni.GetIPProperties().DhcpServerAddresses)
                        {
                            dhcp = dhcpAdress.ToString();
                        }
                    }


                    sub = "255.255.255.0";
                    if (ni.OperationalStatus.ToString() == "Down")
                        ipen = "False";
                    else
                        ipen = "True";

                    // Caption IPAddress IPSubnet DHCPEnabled IPEnabled
                    Console.WriteLine($"{nic}-{ip}-{sub}-{dhcp}-{ipen}");
                    adapters.Add(new String[] { ni.Description, ip, sub, (dhcp == "" ? "False" : "True"), ipen, nic });
                }
            }
            return adapters;
        }
    }
    public class GMedian3
    {
        public UInt16 filtered(UInt16 value)
        {   // возвращает фильтрованное значение
            bufUI16[_counter] = value;
            if (++_counter > 2)
                _counter = 0;
            return (Math.Max(bufUI16[0], bufUI16[1]) == Math.Max(bufUI16[1], bufUI16[2])) ? Math.Max(bufUI16[0], bufUI16[2]) : Math.Max(bufUI16[1], Math.Min(bufUI16[0], bufUI16[2]));
        }
        public Int16 filtered(Int16 value)
        {   // возвращает фильтрованное значение
            bufI16[_counter] = value;
            if (++_counter > 2)
                _counter = 0;
            return (Math.Max(bufI16[0], bufI16[1]) == Math.Max(bufI16[1], bufI16[2])) ? Math.Max(bufI16[0], bufI16[2]) : Math.Max(bufI16[1], Math.Min(bufI16[0], bufI16[2]));
        }
        public UInt32 filtered(UInt32 value)
        {   // возвращает фильтрованное значение
            bufUI32[_counter] = value;
            if (++_counter > 2)
                _counter = 0;
            return (Math.Max(bufUI32[0], bufUI32[1]) == Math.Max(bufUI32[1], bufUI32[2])) ? Math.Max(bufUI32[0], bufUI32[2]) : Math.Max(bufUI32[1], Math.Min(bufUI32[0], bufUI32[2]));
        }
        public Int32 filtered(Int32 value)
        {   // возвращает фильтрованное значение
            bufI32[_counter] = value;
            if (++_counter > 2)
                _counter = 0;
            return (Math.Max(bufI32[0], bufI32[1]) == Math.Max(bufI32[1], bufI32[2])) ? Math.Max(bufI32[0], bufI32[2]) : Math.Max(bufI32[1], Math.Min(bufI32[0], bufI32[2]));
        }
        public float filtered(float value)
        {   // возвращает фильтрованное значение
            buff[_counter] = value;
            if (++_counter > 2)
                _counter = 0;
            return (Math.Max(buff[0], buff[1]) == Math.Max(buff[1], buff[2])) ? Math.Max(buff[0], buff[2]) : Math.Max(buff[1], Math.Min(buff[0], buff[2]));
        }
        public Double filtered(Double value)
        {   // возвращает фильтрованное значение
            bufd[_counter] = value;
            if (++_counter > 2)
                _counter = 0;
            return (Math.Max(bufd[0], bufd[1]) == Math.Max(bufd[1], bufd[2])) ? Math.Max(bufd[0], bufd[2]) : Math.Max(bufd[1], Math.Min(bufd[0], bufd[2]));
        }

        UInt16[] bufUI16 = new UInt16[3];
        Int16[] bufI16 = new Int16[3];
        UInt32[] bufUI32 = new UInt32[3];
        Int32[] bufI32 = new Int32[3];
        Double[] bufd = new Double[3];
        Single[] buff = new Single[3];
        Byte _counter = 0;
    };
    public class ParParse
    {
        private List<(bool, String, String, bool, String)> Pars = new List<(bool, string, string, bool, string)>();
        private int _num = 0;
        private (bool, string, string, bool, string) nullitem = (false, null, null, false, null);
        public int NumofPar { get; }
        public (bool, string, string, bool, string) GetPar(UInt16 num)
        {
            if (Pars[num].Item1)
                return Pars[num];
            else
                return nullitem;
        }
        public (bool, string, string, bool, string) GetPar(String par)
        {
            for (int j = 0; j < _num; j++)
            {
                if ((par == Pars[j].Item2 || par == Pars[j].Item3) && Pars[j].Item1)
                    return Pars[j];
            }
            return nullitem;
        }
        public void AddPar(String shrt, String lng, Boolean key)
        {
            Pars.Add((false, shrt, lng, key, ""));
            _num = Pars.Count;
        }
        public int Parse(String[] arg)
        {
            int rez = 0;
            if (_num == 0)
                return -1;

            if (arg.Length == 0)
                return -1;

            for (int i = 0; i < arg.Length; i++)
            {
                for (int j = 0; j < _num; j++)
                {
                    if (arg[i] == Pars[j].Item2 || arg[i] == Pars[j].Item3)
                    {
                        (bool, string, string, bool, string) tmp = Pars[j];
                        if (Pars[j].Item4)
                        {
                            tmp.Item5 = arg[i + 1];
                        }
                        tmp.Item1 = true;
                        Pars[j] = tmp;
                        rez++;
                    }
                }
            }
            return rez;
        }
    }

}