// Wykorzystując klasy Thread i Fiber napisać program przyjmujący cztery
// parametry m, n, p, q wywołania programu będące liczbami całkowitymi.
// Wątek główny programu tworzy m na n elementową tablicę elementów typu
// real i uruchamia m wątków potomnych i przekazuje każdemu z nich po
// jednym wierszu tej tablicy. Każdy z wątków potomnych tworzy p ścieżek
// i każda ścieżka wylicza sumę kwadratów części wiersza wykonując q iteracji.
// Wątki potomne przełączają się pomiędzy poszczególnymi ścieżkami do momentu
// gdy zostanie wyliczona suma kwadratów całego wiersza. Wątki potomne przekazują
// wyniki do wątku głównego, który wylicza sumę wyników i wypisuje ją na ekranie.
// Uwaga. Wątki muszą pracować równolegle i nie mogą używać zmiennych globalnych.

import core.thread;
import std.stdio : write, writeln, writef, writefln;
import std.conv : parse;
import std.random : uniform;
import std.math : pow;

class DerivedFiber : Fiber {
    private int begin_index;
    private int iterations;
    private real[] row;
    private real* r;
    this(real[] row, int begin_index, int iterations, real* result) {
        this.begin_index = begin_index;
        this.iterations = iterations;
        this.row = row;
        this.r = result;
        super( &run );
    }

private :
    void run() {
        for (int i=0; i<this.iterations; i++) {
            *(this.r) += pow(this.row[begin_index + i], 2);
            this.yield();
        }
    }
}


class DerivedThread : Thread {
    private real[] i;
    private real result;
    private Fiber[] fibers;
    this(real[] i, int p, int q) {
        this.i = i;
        this.result = 0;
        for (int j=0; j<p; j++) {
            fibers ~= new DerivedFiber(this.i, cast(int)(j * (i.length / p)), q, &this.result);
        }
        super(&run);
    }

    private void run() {
        foreach(fiber; fibers) {
            while (fiber.state != Fiber.State.TERM) {
                fiber.call();
            }
        }
    }

    public real getResult() {
        return this.result;
    }
}

int main(string[] args) {
    if (args.length < 5) {
        writeln("Command: ", args[0], " number_m number_n number_p number_q");
        return 1;
    }

    int m = parse!int(args[1]);
    int n = parse!int(args[2]);
    int p = parse!int(args[3]);
    int q = parse!int(args[4]);

    if (n % p !=0) {
        writeln("WARNING: The number of fibers should be divisible by row length!");
        return 1;
    }

    if (p * q != n) {
        writeln("WARNING: The number of iterations should be equal to the row length divided by the number of fibers!");
        return 1;
    }

    real[][] matrix = new real[][](m, n);
    for (int i = 0; i < matrix.length; i++) {
        for (int j = 0; j < matrix[i].length; j++) {
            matrix[i][j] = uniform(0, 50);
        }
    }

    writeln("Utworzono tablicę...");

    foreach (real[] key; matrix) {
        writeln(key);
    }

    writeln("Tworzę wątki...");

    scope group = new ThreadGroup;

    for (int i = 0; i < m; i++){
        group.add(new DerivedThread(matrix[i], p, q));
    }

    writeln("Liczę...");

    foreach (thread; group)
        thread.start();

    writeln("Zbieram odpowiedzi...");

    group.joinAll();

    real result = 0;
    foreach (thread; group) {
        result += pow((cast(DerivedThread)thread).getResult(), 2);
    }

    writeln("Suma kwadratów wynosi: ", result);
    return 0;
}