using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static Int64 sumValue = 0;
        static List<int> randomList = new List<int>();

        static void FillList(int Length)
        {
            var rand = new Random();
            for(int i=0;i<Length;i++)
            {
                randomList.Add(rand.Next(1, 5000));
            }
        }
        static void PartialSum(int Index, int ToSum)
        {

            int sum = 0;
            int range = Index + ToSum;
            

            try
            {
                for (int i = Index; i < range; i++)
                {
                    sum += randomList[i];
                }
            }
            catch(IndexOutOfRangeException)
            { 
            }
            sumValue += sum;

        }
        static List<int> SetChunk(int AmmontOfThreads)
        {
            if (AmmontOfThreads == 0)
                throw new Exception("Ammount of Threads cannot be zero");

            List<int> chunks = new List<int>();
            int toCover = randomList.Count;
            double ch = randomList.Count / AmmontOfThreads;

            for (int i = 0; i < AmmontOfThreads; i++)
            {
                if (i == AmmontOfThreads - 1)
                {
                    chunks.Add(toCover);
                }
                else
                {
                    int p = (int)Math.Floor(ch);
                    chunks.Add(p);
                    toCover -= p;
                }
                    
            }
            return chunks;
        }

        static void Main(string[] args)
        {
            StreamWriter file = new StreamWriter("ParallelTime.txt");
            int numberOfThreads = 1;
            var parallelStopwatch = new Stopwatch();
            List<Thread> threadList = new List<Thread>();
            List<int> listOfChunks = new List<int>();
            List<int> listOfIndex = new List<int>();
            List<long> ticks = new List<long>();
            int n = 10000000;
            FillList(n);

            while (numberOfThreads!=200)
            {
                int tries = 0;
                while (tries<20)
                {
                    FillList(n);
                    listOfChunks = SetChunk(numberOfThreads);
                    int currentIndex = 0;

                    foreach (int chunk in listOfChunks)
                    {
                        listOfIndex.Add(currentIndex);
                        currentIndex += chunk;
                    }

                    parallelStopwatch.Restart();
                    for (int i = 0; i < listOfIndex.Count; i++)
                    {
                        int h = i;//z jakiegos powodu trzeba stworzyc zmienna lokalna dla nowego watku, w przypadku uzywania i crashuje sie
                        var t = new Thread(() => PartialSum(listOfIndex[h], listOfChunks[h]));
                        t.Start();
                        threadList.Add(t);
                    }
                    foreach (var t in threadList)
                        t.Join();

                    parallelStopwatch.Stop();
                    ticks.Add(parallelStopwatch.ElapsedTicks);

                    listOfChunks.Clear();
                    listOfIndex.Clear();
                    threadList.Clear();
                    randomList.Clear();
                    tries++;
                }
                ticks.Sort();
                double avg = ticks[(ticks.Count - 1) / 2];
                double time = (avg / Stopwatch.Frequency) * 1000;
                file.WriteLine(numberOfThreads + ";" + time);

                ticks.Clear();
                numberOfThreads++;
            }
            file.Dispose();
        }  
    }
}