package matrixmultiply;

import java.util.Random;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

class ScalarProductRunnable implements Runnable {
    final Matrix m;
    final int i, j;
    final int[] a, b;

    public ScalarProductRunnable(Matrix m, int i, int j, int[] a, int[] b) {
        this.i = i;
        this.j = j;
        this.m = m;
        this.a = a;
        this.b = b;
    }

    public void run() {
        m.setValue(i, j, Matrix.scalarProduct(a, b));
    }
}

class MatrixRowCalculator implements Runnable {
    private final Matrix A, B, result;
    private final int index;

    public MatrixRowCalculator(Matrix A, Matrix B, Matrix result, int index) {
        this.A = A;
        this.B = B;
        this.result = result;
        this.index = index;
    }

    public void run() {
        for(int i = 0; i < Main.N; i++) {
            result.setValue(index, i, Matrix.scalarProduct(A.getRow(index), B.getColumn(i)));
        }
    }
}


class Matrix {
    public final int rows;
    public final int columns;
    public final int[][] data;

    public Matrix(int rows, int columns) {
        this.rows = rows;
        this.columns = columns;

        data = new int[rows][];
        for(int i = 0; i < rows; i++)
            data[i] = new int[this.columns];
    }

    public Matrix(int rows, int columns, int[] values) {
        this(rows, columns);
        setValues(values);
    }

    public final void setValue(int row, int column, int value) {
        data[row][column] = value;
    }

    public final void setValues(int[] values) {
        for(int i = 0; i < rows; i++)
            for(int j = 0; j < columns; j++)
                data[i][j] = values[i*rows + j];
    }

    public static int scalarProduct(int[] a, int[] b) {
        int value = 0;

        for(int i = 0; i < a.length; i++)
            value += a[i]*b[i];

        return value;
    }

    public int[] getColumn(int column) {
        int[] ret = new int[rows];

        for(int i = 0; i < rows; i++)
            ret[i] = data[i][column];

        return ret;
    }

    public int[] getRow(int row) {
        return data[row];
    }

    public Matrix multiplyWith(Matrix m, ExecutorService s) {
        Matrix ret = new Matrix(rows, columns);


        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < columns; j++) {
                s.submit(new ScalarProductRunnable(ret, i, j, getRow(i), m.getColumn(j)));
            }
        }

        return ret;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for(int i = 0; i < rows; i++) {
            boolean first = true;
            for(int j = 0; j < columns; j++) {
                if(!first)
                    sb.append(" ");
                else
                    first = false;

                sb.append(data[i][j]);
            }
            if(i + 1 < rows)
                sb.append("\n");
        }
        return sb.toString();
    }
}

public class Main {
    static int N = 1000;
    static int P = 1;
    static int T = 1;

    private static void multiply(Matrix A, Matrix B, Matrix result) {
        ExecutorService s = Executors.newFixedThreadPool(P);

        for(int i = 0; i < N; i++) {
            s.submit(new MatrixRowCalculator(A, B, result, i));
        }

        s.shutdown();
        try {
            s.awaitTermination(1, TimeUnit.DAYS);
        } catch(InterruptedException e) {

        }
    }

    public static void main(String[] args) {
        final Random random = new Random();

        Matrix mA = new Matrix(N, N);
        for(int i = 0; i < N; i++)
            for(int j = 0; j < N; j++)
                mA.setValue(i, j, random.nextInt(1000));

        Matrix mB = new Matrix(N, N);
        for(int i = 0; i < N; i++)
            for(int j = 0; j < N; j++)
                mB.setValue(i, j, random.nextInt(1000));

        for(int i = 0; i < T; i++) {
            final ExecutorService s = Executors.newFixedThreadPool(P);
            final long startTime = System.currentTimeMillis();
            Matrix result = new Matrix(N, N);
            multiply(mA, mB, result);
            final long endTime = System.currentTimeMillis();
            System.out.println("took " + (endTime - startTime));
        }
    }
}