package project;

import java.util.Vector;

public class Matrix {
    // leftover matrices that haven't been processed yet
    public static Vector<Matrix> matricesToBeProcessed = new Vector<Matrix>();
    // Det=a11*(-1)^(1+1)*DetA11+a12*(-1)^(1+2)*DetA12 ...
    // +a1n*(-1)^(1+n)*DetA1n
    // valueInParent is a1n*(-1)^(1+n)
    public double valueInParent = 1;
    // how many threads we can have
    public static int threadMax = 1;
    // all the elements in the matrix.
    // it's supposed to be a 2 dimensional array, but this works the same
    public double[] elements;
    // reference to the parent of this submatrix.
    // only the first matrix doesn't have a parent
    public Matrix parent;
    // how many rows/columns this matrix has
    int size;
    // reference to the thread that's calculating this matrix.
    // necessary in order to clear the que of that thread
    public ThreadedMatrix thread;

    // a[x,y]=val
    public void SetElement(double val, int x, int y) {
        elements[size * y + x] = val;
    }

    // constructor
    public Matrix(int _size) {
        size = _size;
        elements = new double[size * size];
        matricesToBeProcessed.add(this);
    }

    // return a[x,y]
    public double Get(int x, int y) {
        return elements[x + y * size];
    }

    // reference to all the threads.
    // each of them needs to know if the others are finished
    public static Vector<ThreadedMatrix> threadedMatrices = new Vector<ThreadedMatrix>();

    // how many processes are left
    public static int numberOfProcesses;

    // function that calculates the determinant of this matrix
    // if the size of this matrix is 3 or bigger, it will return 0 and will push
    // the submatrices into the thread
    public void run() {
        // remove this matrix from the thread que
        thread.Pop(this);
        if (size == 2) {
            //no longer needs to be processed
            matricesToBeProcessed.remove(this);
            // calculate result if this is the lowest level submatrix
            ThreadedMatrix.results[numberOfProcesses - 1] = (elements[0] * elements[3] - elements[1] * elements[2])
                    * valueInParent;
            //decrement remaining processes
            Matrix.numberOfProcesses--;
        } else {
            // create submatrices for every element in the first row
            for (int i = 0; i < size; i++) {
                Matrix sub = new Matrix(size - 1);
                // for a11 the submatrix valueInParent will be
                // (-1)^(i+2)*1*a11=a11
                sub.valueInParent = Math.pow(-1, i + 2) * Get(i, 0) * valueInParent;
                // set the elements of the submatrix
                for (int x = 0; x < size; x++) {
                    if (x != i) {
                        for (int y = 1; y < size; y++) {
                            sub.SetElement(Get(x, y), (x > i ? x - 1 : x), y - 1);
                        }
                    }
                }
                // see which thread has the least amount of processes to
                // calculate
                // push this submatrix into it's que

                ThreadedMatrix smallest = thread;
                int min = 100;
                for (ThreadedMatrix _t : threadedMatrices) {
                    if (_t.que.size() < min) {
                        smallest = _t;
                        min = _t.que.size();
                    }
                }
                smallest.Push(sub);

            }
            matricesToBeProcessed.remove(this);
        }

    }
}