package tasks;

import java.util.Arrays;

public class Matrix {
    private double[][] M;
    private int[] size = {0, 0};

    Matrix(double[][] instance) {
        M = instance;
        this.size[0] = instance.length;
        this.size[1] = instance[0].length;
    }

    private double[][] getMatrix(){
        return this.M;
    }

    void Display() {
        if (Arrays.equals(this.size, new int[]{1, 1})){
            System.out.println("failed.");
            return;
        }
        for (int i = 0; i < this.size[0]; i++){
            for (int j = 0; j < this.size[1]; j++){
                double scale = Math.pow(10, 3);
                System.out.print(Math.round(this.M[i][j] * scale)/scale + " ");
            }
            System.out.println();
        }
    }

    Matrix multiplyScalar(double scalar){
        double[][] mtx = this.M;
        for (int i = 0; i < this.size[0]; i++) {
            for (int j = 0; j < this.size[1]; j++) {
                mtx[i][j] *= scalar;
            }
        }
        return new Matrix(mtx);
    }

    public Matrix addMatrix(Matrix B){
        double[][] res = this.M;
        for (int i = 0; i < this.size[0]; i++){
            for (int j = 0; j < this.size[1]; j++){
                res[i][j] += B.getMatrix()[i][j];
            }
        }
        return new Matrix(res);
    }

    public Matrix subtractMatrix(Matrix B){
        double[][] res = this.M;
        for (int i = 0; i < this.size[0]; i++){
            for (int j = 0; j < this.size[1]; j++){
                res[i][j] -= B.getMatrix()[i][j];
            }
        }
        return new Matrix(res);
    }

    public Matrix multiplyMatrices(Matrix secondMatrix) {
        int r1 = this.size[0];
        int c1 = this.size[1];
        int r2 =secondMatrix.getSize()[0];
        int c2 = secondMatrix.getSize()[1];

        if (r2 != c1){
            System.out.println("Cannot multiply matrices");
            return new Matrix(new double[1][1]);
        }

        double[][] product = new double[r1][c2];
        for(int i = 0; i < r1; i++) {
            for (int j = 0; j < c2; j++) {
                for (int k = 0; k < c1; k++) {
                    product[i][j] += this.M[i][k] * secondMatrix.getMatrix()[k][j];
                }
            }
        }
        return new Matrix(product);
    }

    private int[] getSize() {
        return this.size;
    }


    Matrix Transposed(){
        double[][] res = new double[this.size[1]][this.size[0]];
        for (int i = 0; i < this.size[1]; i++) {
            for (int j = 0; j < this.size[0]; j++) {
                res[i][j] = this.M[j][i];
            }
        }
        return new Matrix(res);
    }

    public double Determinant(Matrix mtx) {
        double[][] matrix = mtx.getMatrix();
        if (this.size[0] != this.size[1]){
            System.out.println("Given input is not square matrix.");
            return Double.MIN_VALUE;
        }

        double result = 0;
        if (matrix.length == 1) {
            result = matrix[0][0];
            return result;
        }
        if (matrix.length == 2) {
            result = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
            return result;
        }
        for (int i = 0; i < matrix[0].length; i++) {
            double[][] temp = new double[matrix.length - 1][matrix[0].length - 1];

            for (int j = 1; j < matrix.length; j++) {
                for (int k = 0; k < matrix[0].length; k++) {
                    if (k < i) {
                        temp[j - 1][k] = matrix[j][k];
                    } else if (k > i) {
                        temp[j - 1][k - 1] = matrix[j][k];
                    }
                }
            }
            result += matrix[0][i] * Math.pow(-1, (int) i) * Determinant(new Matrix(temp));
        }
        return result;
    }

    public Matrix Inverse(){
        double[][] matrix = this.Transposed().getMatrix();
        if (matrix.length != 3 || matrix[0].length != 3){
            return new Matrix(new double[1][1]);
        }

        double[][] adj = new double[3][3];
        adj[0][0] = Determinant(new Matrix(new double[][]{{matrix[1][1], matrix[1][2]}, {matrix[2][1], matrix[2][2]}}));
        adj[0][1] = Determinant(new Matrix(new double[][]{{matrix[1][0], matrix[1][2]}, {matrix[2][0], matrix[2][2]}}));
        adj[0][2] = Determinant(new Matrix(new double[][]{{matrix[1][0], matrix[1][1]}, {matrix[2][0], matrix[2][1]}}));
        adj[1][0] = Determinant(new Matrix(new double[][]{{matrix[0][1], matrix[0][2]}, {matrix[2][1], matrix[2][2]}}));
        adj[1][1] = Determinant(new Matrix(new double[][]{{matrix[0][0], matrix[0][2]}, {matrix[2][0], matrix[2][2]}}));
        adj[1][2] = Determinant(new Matrix(new double[][]{{matrix[0][0], matrix[0][1]}, {matrix[2][0], matrix[2][1]}}));
        adj[2][0] = Determinant(new Matrix(new double[][]{{matrix[0][1], matrix[0][2]}, {matrix[1][1], matrix[1][2]}}));
        adj[2][1] = Determinant(new Matrix(new double[][]{{matrix[0][0], matrix[0][2]}, {matrix[1][0], matrix[1][2]}}));
        adj[2][2] = Determinant(new Matrix(new double[][]{{matrix[0][0], matrix[0][1]}, {matrix[1][0], matrix[1][1]}}));

        for (int i = 0; i < 3; i++){
            for (int j = 0; j < 3; j++){
                adj[i][j] *= Math.pow(-1, i + j);
            }
        }

        return new Matrix(adj).multiplyScalar(1./this.Determinant(this));
    }

}