using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Lab2 {
    public static class SimplePerfomanceEvaluator {
        public static IDictionary<string, int> EvaluateArrayPerfomance<TItem>(int nRows, int nColumns, Action<TItem> testAction) where TItem : class, new() {
            var result = new Dictionary<string, int>();

            //TwoDimensionalArray

            var twoDimensionalArray = new TItem[nRows, nColumns];
            for (int rowIndex = 0; rowIndex < twoDimensionalArray.GetLength(0); rowIndex++) {
                for (int columnIndex = 0; columnIndex < twoDimensionalArray.GetLength(1); columnIndex++) {
                    twoDimensionalArray[rowIndex, columnIndex] = new TItem();
                }
            }

            var startTime = Environment.TickCount;

            for (int rowIndex = 0; rowIndex < twoDimensionalArray.GetLength(0); rowIndex++) {
                for (int columnIndex = 0; columnIndex < twoDimensionalArray.GetLength(1); columnIndex++) {
                    testAction(twoDimensionalArray[rowIndex, columnIndex]);
                }
            }
            var endTime = Environment.TickCount;
            result.Add("Two dimensional array", endTime - startTime);

            //OneDimensionalArray
            int size = nRows * nColumns;
            var oneDimensionalArray = new TItem[size];

            for (var index = 0; index < oneDimensionalArray.GetLength(0); index++) {
                oneDimensionalArray[index] = new TItem();
            }

            startTime = Environment.TickCount;

            for (var index = 0; index < oneDimensionalArray.GetLength(0); index++) {
                testAction(oneDimensionalArray[index]);
            }

            endTime = Environment.TickCount;
            result.Add("One dimensional array", endTime - startTime);


            //JaggedArray;

            var rand = new Random();
            var maxSize = nRows * nColumns;
            int koef = (int)Math.Sqrt(maxSize); //Magic
            var rowsCount = rand.Next(1, maxSize / koef);
            var jaggedArray = new TItem[rowsCount][];
            var residual = maxSize - rowsCount;
            int curentSize = 0;

            for (int i = 0; i < rowsCount; i++) {
                var columnsCount = rand.Next(1, (residual / (koef / 2)) + 1);

                if (i == rowsCount - 1 && curentSize != maxSize) {
                    columnsCount = Math.Abs(curentSize - maxSize);
                }
                curentSize += columnsCount;
                jaggedArray[i] = new TItem[columnsCount];
                for (var j = 0; j < columnsCount; j++) {
                    jaggedArray[i][j] = new TItem();
                }
            }

            startTime = Environment.TickCount;
            int p = 0;
            for (int rowIndex = 0; rowIndex < jaggedArray.GetLength(0); rowIndex++) {
                Console.WriteLine(jaggedArray[rowIndex].Length);
                p += jaggedArray[rowIndex].Length;
                for (int columnIndex = 0; columnIndex < jaggedArray[rowIndex].Length; columnIndex++) {
                    testAction(jaggedArray[rowIndex][columnIndex]);
                }
            }
            endTime = Environment.TickCount;

            result.Add("Jagged array", endTime - startTime);

            return result;
        }
    }
}