package project;

//for the scanner getting decimals correctly
import java.util.Locale;
//for the random matrix generator
import java.util.Random;
//for the text file reading
import java.util.Scanner;
//for the text file input/output
import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;

public class test {

    // possible args
    // -n 13 - size 13, elements are randomly generated
    // -i m3x-data.in - matrix and size are stored in a text file m3x-data.in
    // -o m3x-data.out - result of matrix is stored in a text file m3x-data.out
    // -t 3 - specify how many threads will be running
    // -q - don't print whenever a thread starts/stops, only print how long it
    // took for the whole process

    // see exactly how many size 2 matrices the program will have to calculate
    // using this as the index for the array of results
    public static int predictProcesses(int x) {
        return (x == 2 ? 1 : x * predictProcesses(x - 1));
    }

    // should the program report when it's started/stopped a thread
    public static boolean quiet = false;

    // how many threads the program will be running
    public static int threadMax = 1;

    public static void main(String[] args) {
        Matrix matrix = null;
        int size = 0;
        int inputMethod = 0;
        // need this to know which input method to exclude, if both are in the
        // args
        // 0 means it hasn't it been input yet
        // 1 for random
        // 2 for text file
        String outputFile = ""; // won't save if it's still ""
        double result = 0;
        Random r = new Random();
        for (int i = 0; i < args.length; i += 2) {
            // input random elements into the matrix
            switch (args[i]) {
            case "-n": {
                if (inputMethod == 0) {
                    size = Integer.parseInt(args[i + 1]);
                    matrix = new Matrix(size);
                    for (int p = 0; p < size; p++) {
                        for (int d = 0; d < size; d++) {
                            int Low = 10;
                            int High = 100;
                            int Result = r.nextInt(High - Low) + Low;
                            matrix.SetElement(Result, p, d);
                        }
                    }
                    inputMethod = 1;
                }
                break;
            }
            // input elements into the matrix from a text file
            case "-i": {
                if (inputMethod == 0) {
                    File file = new File(args[i + 1]);
                    try {
                        Scanner input = new Scanner(file).useLocale(Locale.US);
                        size = input.nextInt();
                        matrix = new Matrix(size);
                        for (int p = 0; p < size; p++) {
                            for (int d = 0; d < size; d++) {
                                matrix.SetElement(input.nextDouble(), p, d);
                            }
                        }
                        input.close();
                    } catch (FileNotFoundException e) {
                        e.printStackTrace();
                    }
                    inputMethod = 2;
                }
                break;
            }
            // output file
            case "-o": {
                outputFile = args[i + 1];
                break;
            }
            // set thread count
            case "-t": {
                threadMax = Integer.parseInt(args[i + 1]);
                Matrix.threadMax = threadMax;
                break;
            }
            // quiet or not
            case "-q": {
                quiet = true;
                break;
            }
            }
        }
        // start the process
        if (matrix != null) {
            // get start time
            long starttime = System.currentTimeMillis();
            // calculate exactly how many processes the algorithm will do
            Matrix.numberOfProcesses = predictProcesses(size);
            // create the array of results
            ThreadedMatrix.results = new double[Matrix.numberOfProcesses];
            // create threads
            for (int i = 0; i < threadMax; i++) {
                ThreadedMatrix p = new ThreadedMatrix(i);
                Thread t = new Thread(p);
                p.thisThread = t;
                Matrix.threadedMatrices.add(p);
            }
            // add matrix to the first thread
            Matrix.threadedMatrices.get(0).Push(matrix);
            // start threads
            for (ThreadedMatrix thread : Matrix.threadedMatrices) {
                thread.thisThread.start();
            }
            // main thread loop
            while (true) {
                // check if threads have finished their ques
                boolean finish = true;
                for (ThreadedMatrix thread : Matrix.threadedMatrices) {
                    if (thread.que.size() > 0) {
                        // unpause a thread if it has new matrices
                        if (thread.paused) {
                            synchronized (thread.thisThread) {
                                thread.paused = false;
                                thread.thisThread.notify();
                            }
                        }
                        // not finished, continue
                        finish = false;
                        break;
                    }
                }
                // also check aditional factors
                // tell the threads that they need to finish
                if (finish && Matrix.matricesToBeProcessed.size() == 0) {
                    for (ThreadedMatrix thread : Matrix.threadedMatrices) {
                        synchronized (thread.thisThread) {
                            thread.finished = true;
                            thread.thisThread.notify();
                        }
                    }
                    break;
                }
            }
            // wait for the threads to finish
            try {
                for (ThreadedMatrix thread : Matrix.threadedMatrices) {
                    thread.thisThread.join();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // calculate result
            for (int i = 0; i < ThreadedMatrix.results.length; i++) {
                result += ThreadedMatrix.results[i];
            }
            // print matrix
            for (int p = 0; p < size; p++) {
                for (int d = 0; d < size; d++) {
                    System.out.print(matrix.Get(d, p) + " ");
                }
                System.out.print("\n");
            }
            // report times
            long calcTimeTotal = System.currentTimeMillis() - starttime;
            System.out.print("total time: " + calcTimeTotal + " ms\n");
            System.out.print("\nresult: " + result);
            // save output file
            if (outputFile != "") {
                try {
                    PrintWriter out = new PrintWriter(outputFile);
                    out.println(result);
                    out.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }

    }

}