using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Net.NetworkInformation;
using System.Net;
using System.Diagnostics;

namespace avs_l1
{
    public partial class MainForm : Form
    {
        List<IPAddressInfo> addressInfoAssemblyList = new List<IPAddressInfo>();
        Stopwatch ipAnalysisStopwatch = new Stopwatch();

        public int IPsCount { get; private set; }
        //public double IPsReceivedCount { get; private set; }
        private int receivedTotal = 0;
        private Object receivedTotalObj = new Object();
        public MainForm()
        {
            InitializeComponent();
            int workerThreads, completionPortThreads;
            ThreadPool.GetAvailableThreads(out workerThreads, out completionPortThreads);
            try
            {
                //ThreadPool.SetMinThreads(500, 100);
                ThreadPool.SetMinThreads(200, 100);
                ThreadPool.QueueUserWorkItem(delegate { }, new object[] { }); // Create threads
            }
            catch { /* Ignore */ }
            dataGridView.Columns[0].SortMode = DataGridViewColumnSortMode.Programmatic;
            //IPAddress ip1 = IPAddress.Parse("1.1.1.1");
            //IPAddress ip2 = IPAddress.Parse("1.1.2.1");

            //List<IPAddress> adrss = new List<IPAddress>();
            //for (long i = ip1.Address; i < ip2.Address; ++i)
            //    adrss.Add(new IPAddress(i));
            //;
        }

        private void buttonExit_Click(object sender, EventArgs e)
        {
            Cursor = Cursors.Default;
            Environment.Exit(0);
        }

        private void buttonStart_Click(object sender, EventArgs e)
        {
            addressInfoAssemblyList.Clear();
            ipAnalysisStopwatch.Reset();
            ipAnalysisStopwatch.Start();

            Cursor = Cursors.WaitCursor;
            dataGridView.Rows.Clear();
            //IPsReceivedCount = 0;
            receivedTotal = 0;
            progressBar.Value = 0;
            start.Enabled = false;
            LinkedList<IPAddress> addresses, addressesTemp;

            try
            {
                addresses = GenerateIpRange();
                addressesTemp = GenerateIpRange();
            }
            catch
            {
                MessageBox.Show("Ошибка при генерации диапазона.", "Ошибка");
                start.Enabled = true;
                Cursor = Cursors.Default;
                return;
            }

            for (int i = 0; i < addresses.Count; ++i)
            {
                dataGridView.Rows.Insert(i,
                        new object[]
                        {
                            addresses.ElementAt(i),
                            "", ""
                        }
                    );
            }

            IPsCount = addresses.Count;
            int exceptionsCount = 0;
            foreach (IPAddress address in addressesTemp)
            {
                Ping p = new Ping();
                p.PingCompleted += AnalyzePingAndUpdateTable;
                try
                {
                    p.SendAsync(address, address);
                    ThreadPool.QueueUserWorkItem(AnalyzeDnsNameAndUpdateTable
                        , new object[] { address });
                }
                catch {
                    AddRow(
                            new IPAddressInfo(
                                    address.ToString(),
                                    "-",
                                    "-"
                                )
                        );
                    if ((++exceptionsCount) == IPsCount)
                    {
                        MessageBox.Show("Диапазон состоит из зарезервированных IP-адресов");
                        progressBar.Value = progressBar.Maximum;
                        receivedTotal = 0;
                        start.Enabled = true;
                        Cursor = Cursors.Default;
                    }

                };
            }
        }

        private void AnalyzePingAndUpdateTable(object sender, PingCompletedEventArgs e)
        {
            //lock (receivedTotalObj)
            //{
            //}

            IPAddress ipAddress = e.UserState as IPAddress;
            String replyStatus = e.Reply.Status.ToString();
            //lock (addressInfoAssemblyList)
            //{
            for (int i = 0; i < addressInfoAssemblyList.Count; ++i)
            {
                // If some address info already exists (info from dns analysis)
                if (addressInfoAssemblyList[i].Address.Equals(ipAddress))
                {
                    addressInfoAssemblyList[i].Status = replyStatus;
                    receivedTotal++;
                    AddRow(addressInfoAssemblyList[i]);
                    return;
                }
            }
            //}
            // Else, if there is no any info about ip address,
            // add an instance of IPAddressInfo object with ping reply status
            IPAddressInfo info = new IPAddressInfo();
            info.Address = ipAddress;
            info.Status = replyStatus;
            addressInfoAssemblyList.Add(info);


        }

        private void AnalyzeDnsNameAndUpdateTable(object ipObj)
        {
            //lock(receivedTotalObj)
            //{
            //}

            IPAddress ipAddress = (IPAddress)((object[])ipObj)[0];
            String dnsName = "";
            IPHostEntry entry = null;
            try
            {

                entry = Dns.GetHostEntry(ipAddress.ToString());
            }
            catch
            {
                dnsName = "Неизвестно";
            }
            if (entry != null)
                dnsName = entry.HostName;
            lock (addressInfoAssemblyList)
            {
                for (int i = 0; i < addressInfoAssemblyList.Count; ++i)
                {
                    // If some address info already exists (info from ping)
                    if (addressInfoAssemblyList[i].Address.Equals(ipAddress))
                    {
                        addressInfoAssemblyList[i].Name = dnsName;
                        receivedTotal++;
                        AddRow(addressInfoAssemblyList[i]);
                        return;
                    }
                }
            }
            // Else, if there is no any info about ip address,
            // add an instance of IPAddressInfo object with DNS name
            IPAddressInfo info = new IPAddressInfo();
            info.Address = ipAddress;
            info.Name = dnsName;
            addressInfoAssemblyList.Add(info);
        }


        delegate void AddRowCallback(IPAddressInfo info);
        private void AddRow(IPAddressInfo info)
        {
            if (this.dataGridView.InvokeRequired)
            {
                AddRowCallback arc = new AddRowCallback(AddRow);
                this.Invoke(arc, new object[] { info });
            }
            else
            {
                label11.Text = receivedTotal.ToString();

                string ipstr = info.Address.ToString();
                var rows = dataGridView.Rows;
                for (int i = 0; i < rows.Count; ++i)
                {
                    if (rows[i].Cells[0].Value.ToString().Equals(ipstr))
                    {
                        rows[i].SetValues(
                            ipstr,
                            info.Status,
                            info.Name
                            );
                    }
                }

                // Update progress bar

                //SortGridAcending();
                progressBar.Value = (int)(((double)receivedTotal /*/ 2d */ / IPsCount) * 100d);
                if (receivedTotal >= IPsCount)
                {
                    progressBar.Value = progressBar.Maximum;
                    receivedTotal = 0;
                    MessageBox.Show("Проверено " + IPsCount + " IP - адресов"
                    + "\nЗа " + ipAnalysisStopwatch.Elapsed.ToString(), "Результат");
                    progressBar.Value = progressBar.Maximum;
                    start.Enabled = true;
                    Cursor = Cursors.Default;
                }

                // Sort list
                //dataGridView.Sort(dataGridView.Columns[0], ListSortDirection.Ascending);
            }
        }

        private LinkedList<IPAddress> GenerateIpRange()
        {
            short from1, from2, from3, from4,
                to1, to2, to3, to4;
            from1 = Convert.ToInt16(this.from1.Text);
            from2 = Convert.ToInt16(this.from2.Text);
            from3 = Convert.ToInt16(this.from3.Text);
            from4 = Convert.ToInt16(this.from4.Text);

            to1 = Convert.ToInt16(this.to1.Text);
            to2 = Convert.ToInt16(this.to2.Text);
            to3 = Convert.ToInt16(this.to3.Text);
            to4 = Convert.ToInt16(this.to4.Text);

            if (from1 > to1)
                throw new Exception();
            else if (from2 > to2 && from1 == to1)
                throw new Exception();
            else if (from3 > to3 && from2 == to2)
                throw new Exception();
            else if (from4 > to4 && from3 == to3)
                throw new Exception();


            LinkedList<IPAddress> addresses = new LinkedList<IPAddress>();
            short cur1 = from1;
            short cur2 = from2;
            short cur3 = from3;
            short cur4 = from4;
            while (
                cur1 != to1 ||
                cur2 != to2 ||
                cur3 != to3 ||
                cur4 != to4
                )
            {
                IPAddress ip =
                        new IPAddress(new byte[] {
                            (byte) cur1,
                            (byte) cur2,
                            (byte) cur3,
                            (byte) cur4
                        });

                addresses.AddLast(ip);
                cur4++;
                if (cur4 == 256)
                {
                    cur4 = 0;
                    cur3++;
                }
                if (cur3 == 256)
                {
                    cur4 = cur3 = 0;
                    cur2++;
                }
                if (cur2 == 256)
                {
                    cur2 = cur3 = cur4 = 0;
                    cur1++;
                }

            }

            addresses.AddLast(new IPAddress(new byte[] {
                (byte) cur1,
                (byte) cur2,
                (byte) cur3,
                (byte) cur4
            }));

            return addresses;
        }

        private void dataGridView_MouseUp(object sender, MouseEventArgs e)
        {
            LinkedList<IPAddress> ips = new LinkedList<IPAddress>();
            foreach (var row in dataGridView.SelectedRows)
            {
                String ipAsString = ((DataGridViewRow)row).Cells[0].Value.ToString();
                ips.AddLast(IPAddress.Parse(ipAsString));
            }
            if (ips.Count >= 3)
                AnalyzeIPRange(ips);
        }

        private void AnalyzeIPRange(LinkedList<IPAddress> ips)
        {
            IPAddress mask = IPAddressInfo.GetMask(ips);
            IPAddress networkAddress = IPAddressInfo.GetNetworkAddress(ips);
            IPAddress broadcastAddress = IPAddressInfo.GetBroadcastAddress(ips);
            IPAddress gatewayAddress = IPAddressInfo.GetGatewayAddress(ips);

            this.mask.Text = mask.ToString();
            this.network.Text = networkAddress.ToString();
            this.broadcast.Text = broadcastAddress.ToString();
            this.gateway.Text = gatewayAddress.ToString();

            this.mask.Invalidate();
            this.mask.Invalidate();
            this.broadcast.Invalidate();
            ;
        }

        private void SortGridAcending()
        {
            IPAddressComparer comparer = new IPAddressComparer();
            dataGridView.Sort(comparer);
            return;
            IPAddress[] adrss = new IPAddress[dataGridView.Rows.Count];
            for (int i = 0; i < dataGridView.Rows.Count; ++i)
            {
                adrss[i] = IPAddress.Parse(
                        dataGridView.Rows[i].Cells[0].Value.ToString()
                    );
            }
            var rows = dataGridView.Rows;
            for (int i = rows.Count - 1; i > 0; --i)
            {
                for (int j = 1; j < i; ++j)
                {

                    IPAddress ip1 = adrss[j];
                    IPAddress ip2 = adrss[j - 1];

                    //if (!compareIPAddresses(ip1, ip2))
                    //{
                    //    // Swap i and j

                    //    var ir = rows[i];
                    //    var jr = rows[j];
                    //    rows.Remove(ir);
                    //    rows.Remove(jr);
                    //    rows.Insert(j, ir);
                    //    rows.Insert(i, jr);

                    //    //var temp = rows[i];
                    //    //rows[i] = rows[j];

                    //}
                }
            }
            dataGridView.InvalidateColumn(0);
            ;

        }

        private void dataGridView_ColumnHeaderMouseClick(object sender, DataGridViewCellMouseEventArgs e)
        {
            if (e.ColumnIndex == 0)
                SortGridAcending();
        }
        public class IPAddressComparer : System.Collections.IComparer
        {
            public int Compare(object x, object y)
            {
                var r1 = x as DataGridViewRow;
                var r2 = y as DataGridViewRow;

                return CompareIPAddresses(
                        IPAddress.Parse(r1.Cells[0].Value.ToString()),
                        IPAddress.Parse(r2.Cells[0].Value.ToString())
                    );
                //return compareIPAddresses(x as IPAddress, y as IPAddress);
            }
            public static int CompareIPAddresses(IPAddress ip1, IPAddress ip2)
            {
                String[] strBytes1 = ip1.ToString().Split('.');
                String[] strBytes2 = ip2.ToString().Split('.');
                byte[] bytes1 = new byte[4];
                byte[] bytes2 = new byte[4];
                for (int i = 0; i < 4; ++i)
                {
                    bytes1[i] = Convert.ToByte(strBytes1[i]);
                    bytes2[i] = Convert.ToByte(strBytes2[i]);
                }
                bool res = false;
                if (bytes1[3] > bytes2[3])
                    res = true;
                if (bytes1[3] < bytes2[3])
                    res = false;

                if (bytes1[2] > bytes2[2])
                    res = true;
                if (bytes1[2] < bytes2[2])
                    res = false;

                if (bytes1[1] > bytes2[1])
                    res = true;
                if (bytes1[1] < bytes2[1])
                    res = false;

                if (bytes1[0] > bytes2[0])
                    res = true;
                if (bytes1[0] < bytes2[0])
                    res = false;
                if (res) return 1;
                else return -1;
            }
        }
    }

    class IPAddressInfo
    {
        public IPAddress Address = null;
        public string Name = null;
        public String Status = null;

        public IPAddressInfo(IPAddress address)
        {
            this.Address = address;
        }
        public IPAddressInfo() { }

        public IPAddressInfo(string address, string name, string status)
        {
            Address = IPAddress.Parse(address);
            Name = name;
            Status = status;
        }

        public override string ToString()
        {
            return Address.ToString() + " " + Status + " " + Name;
        }
        public static IPAddress GetNetworkAddress(LinkedList<IPAddress> ipRange)
        {
            return new IPAddress(ipRange.First().Address & GetMask(ipRange).Address);
        }
        public static IPAddress GetGatewayAddress(LinkedList<IPAddress> ipRange)
        {
            try
            {
                return new IPAddress(GetNetworkAddress(ipRange).Address + (1 << 24));
            }
            catch (Exception e)
            {
                MessageBox.Show("БАГ" + ipRange.ToString() + "\n" + e.ToString(), "public static IPAddress GetGatewayAddress(LinkedList<IPAddress> ipRange)");
                return new IPAddress(0);
            }
        }
        public static IPAddress GetBroadcastAddress(LinkedList<IPAddress> ipRange)
        {
            String smask = IPAddressToBinaryString(GetMask(ipRange));

            //smask = Reverse(smask);

            String notSMask = "";
            for (int i = 0; i < smask.Length; ++i)
            {
                if (smask[i].Equals('1'))
                    notSMask = '0' + notSMask;
                else
                    notSMask = '1' + notSMask;
            }

            long res = Convert.ToInt64(notSMask, 2);
            var t = new IPAddress(res);
            var resIP = new IPAddress(res | ipRange.First().Address);
            return resIP;
        }
        public static IPAddress GetMask(LinkedList<IPAddress> ipRange)
        {
            var first = ipRange.First();
            var last = ipRange.Last();
            // Find max and min IP in range
            foreach (IPAddress current in ipRange)
            {
                if (String.Compare
                    (
                        IPAddressToBinaryString(first),
                        IPAddressToBinaryString(current)
                    ) == 1)
                    first = current;
                if (String.Compare
                    (
                        IPAddressToBinaryString(last),
                        IPAddressToBinaryString(current)
                    ) == -1)
                    last = current;

                //if (first.GetAddressBytes()[0] > current.GetAddressBytes()[0])
                //    first = current;
                //else if (first.GetAddressBytes()[1] > current.GetAddressBytes()[1])
                //    first = current;
                //else if (first.GetAddressBytes()[2] > current.GetAddressBytes()[2])
                //    first = current;
                //else if (first.GetAddressBytes()[3] > current.GetAddressBytes()[3])
                //    first = current;

                //if (last.GetAddressBytes()[0] < current.GetAddressBytes()[0])
                //    last = current;
                //else if (last.GetAddressBytes()[1] < current.GetAddressBytes()[1])
                //    last = current;
                //else if (last.GetAddressBytes()[2] < current.GetAddressBytes()[2])
                //    last = current;
                //else if (last.GetAddressBytes()[3] < current.GetAddressBytes()[3])
                //    last = current;
            }

            String mask = "";
            var ip1 = IPAddressToBinaryString(first);
            var ip2 = IPAddressToBinaryString(last);
            bool isMatchUp = true;

            for (int i = 0; i < ip1.Length; ++i)
            {
                if (isMatchUp)
                    isMatchUp = ip1[i].Equals(ip2[i]);

                if (isMatchUp)
                    mask = mask + "1";
                else
                    mask = mask + "0";
            }
            byte b1, b2, b3, b4;
            b1 = Convert.ToByte(mask.Substring(0, 8), 2);
            b2 = Convert.ToByte(mask.Substring(8, 8), 2);
            b3 = Convert.ToByte(mask.Substring(16, 8), 2);
            b4 = Convert.ToByte(mask.Substring(24, 8), 2);

            return new IPAddress(new byte[] { b1, b2, b3, b4 });
        }

        public static String IPAddressToBinaryString(IPAddress ip)
        {
            String charArray =
                ResizeTo(Convert.ToString(ip.GetAddressBytes()[0], 2), 8) +
                ResizeTo(Convert.ToString(ip.GetAddressBytes()[1], 2), 8) +
                ResizeTo(Convert.ToString(ip.GetAddressBytes()[2], 2), 8) +
                ResizeTo(Convert.ToString(ip.GetAddressBytes()[3], 2), 8);
            return charArray;
        }

        private static String ResizeTo(String str, int size)
        {
            while (str.Length < size)
                str = "0" + str;
            return str;
        }
    }
}