using System;
using System.Collections;
using System.Collections.Generic;

namespace QiHe.CodeLib
{
    /// <summary>
    /// The Algorithm object is used to perform the calculating tasks.
    /// </summary>
    public class Algorithm
    {
        public static byte[] ArraySection(byte[] data, int index, int count)
        {
            byte[] section = new byte[count];
            Array.Copy(data, index, section, 0, count);
            return section;
        }
        /// <summary>
        /// Compares two arrays
        /// </summary>
        /// <param name="bytes">The Array</param>
        /// <param name="data">The Array</param>
        /// <returns></returns>
        public static bool ArrayEqual(byte[] bytes, byte[] data)
        {
            if (bytes.Length == data.Length)
            {
                return ArrayEqual(bytes, data, bytes.Length);
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Compares two arrays
        /// </summary>
        /// <param name="a">The Array</param>
        /// <param name="b">The Array</param>
        /// <param name="count">The count.</param>
        /// <returns></returns>
        public static bool ArrayEqual(byte[] a, byte[] b, int count)
        {
            for (int i = 0; i < count; i++)
            {
                if (a[i] != b[i])
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>
        /// Sets the indice on an array
        /// </summary>
        /// <param name="length">The length.</param>
        /// <returns></returns>
        public static int[] ArrayIndice(int length)
        {
            int[] indice = new int[length];
            for (int i = 0; i < length; i++)
            {
                indice[i] = i;
            }
            return indice;
        }
        /// <summary>
        /// Looks for the maximum length of the ArrayList
        /// </summary>
        /// <param name="list">list of lists</param>
        /// <returns>the maximum length</returns>
        public static int Maximum(ArrayList list)
        {
            int max = 0;
            foreach (ICollection sublist in list)
            {
                if (max < sublist.Count)
                {
                    max = sublist.Count;
                }
            }
            return max;
        }
        /// <summary>
        /// Sums the specified list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static int Sum(IList<int> list)
        {
            int sum = 0;
            foreach (int n in list)
            {
                sum += n;
            }
            return sum;
        }

        /// <summary>
        /// Copies the array.
        /// </summary>
        /// <param name="src">The SRC.</param>
        /// <param name="dest">The dest.</param>
        /// <param name="start">The start.</param>
        public static void CopyArray(byte[] src, byte[] dest, int start)
        {
            int j = 0;
            for (int i = start; i < start + dest.Length; i++)
            {
                dest[j++] = src[i];
            }
        }


        /// <summary>
        /// Maximums the specified list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static int Maximum(IEnumerable<int> list)
        {
            int max = int.MinValue;
            foreach (int num in list)
            {
                if (max < num)
                {
                    max = num;
                }
            }
            return max;
        }

        /// <summary>
        /// Minimums the specified list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static int Minimum(IEnumerable<int> list)
        {
            int min = int.MaxValue;
            foreach (int num in list)
            {
                if (min > num)
                {
                    min = num;
                }
            }
            return min;
        }

        /// <summary>
        /// Minimums the specified list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static uint Minimum(IEnumerable<uint> list)
        {
            uint min = uint.MaxValue;
            foreach (uint num in list)
            {
                if (min > num)
                {
                    min = num;
                }
            }
            return min;
        }

        /// <summary>
        /// Return the postion of the maximum in the list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static int PosofMaximum(IList<int> list)
        {
            int index = 0;
            int max = list[0];
            for (int i = 1; i < list.Count; i++)
            {
                if (list[i] > max)
                {
                    max = list[i];
                    index = i;
                }
            }
            return index;
        }

        /// <summary>
        /// Return the postion of the Minimum in the list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static int PosofMinimum(IList<int> list)
        {
            int index = 0;
            int min = list[0];
            for (int i = 1; i < list.Count; i++)
            {
                if (list[i] < min)
                {
                    min = list[i];
                    index = i;
                }
            }
            return index;
        }

        /// <summary>
        /// Return the postion of the Minimum in the list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static int PosofMinimum(int[] list)
        {
            int index = 0;
            int min = list[0];
            for (int i = 1; i < list.Length; i++)
            {
                if (list[i] < min)
                {
                    min = list[i];
                    index = i;
                }
            }
            return index;
        }


        /// <summary>
        /// Return the postion of the Maximum in the list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static List<int> PosofMaximums(IList<int> list)
        {
            int max = int.MinValue;
            List<int> maxIndice = new List<int>();
            for (int index = 0; index < list.Count; index++)
            {
                int num = list[index];
                if (num > max)
                {
                    max = num;
                    maxIndice.Clear();
                }
                if (num == max)
                {
                    maxIndice.Add(index);
                }
            }
            return maxIndice;
        }

        /// <summary>
        /// Return the postion of the Minimum in the list.
        /// </summary>
        /// <param name="list">The list.</param>
        /// <returns></returns>
        public static List<int> PosofMinimums(IList<int> list)
        {
            int min = int.MaxValue;
            List<int> minIndice = new List<int>();
            for (int index = 0; index < list.Count; index++)
            {
                int num = list[index];
                if (num < min)
                {
                    min = num;
                    minIndice.Clear();
                }
                if (num == min)
                {
                    minIndice.Add(index);
                }
            }
            return minIndice;
        }

        /// <summary>
        /// Flats the specified groups.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="groups">The groups.</param>
        /// <returns></returns>
        public static List<T> Flat<T>(List<List<T>> groups)
        {
            List<T> items = new List<T>();
            foreach (List<T> group in groups)
            {
                items.AddRange(group);
            }
            return items;
        }
    }
}