package lab1;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

public class Matrix {

    private ArrayList<Vector> set = new ArrayList<Vector>();

    public Matrix() {
    }

    public Matrix(Vector... vectors) {
        set.addAll(Arrays.asList(vectors));
    }

    public Matrix(Collection<Vector> vectors) {
        set.addAll(vectors);
    }

    private Matrix(Matrix x) {
        set.addAll(x.set);
    }

    /**
     * @throws IllegalArgumentException если складываешь матрицы разных рамеров
     */
    public Matrix addMatrix(Matrix x) {
        if (sameDimesion(this, x)) {
            Matrix m = new Matrix(this);
            for (int i = 0; i < rowsCount(); i++) {
                m.setRow(i, m.getRow(i).addVector(x.getRow(i)));
            }
            return m;
        } else {
            throw new IllegalArgumentException("Размерность матриц должна совпадать");
        }
    }

    public Matrix productScalar(double aValue) {
        Matrix v = new Matrix();
        for (Vector row : set) {
            v.add(row.scalarProduct(aValue));
        }
        return v;
    }

    public Matrix transpose() {
        Matrix m = new Matrix();
        for (int i = 0; i < columnsCount(); i++) {
            m.add(getCol(i));
        }
        return m;
    }

    public Matrix productVector(Vector v) {
        Matrix m = new Matrix(v);
        return productMatrix(m);
    }

    /**
     * @throws IllegalArgumentException если пытаешься умножить несогласованные
     * матрицы
     */
    public Matrix productMatrix(Matrix mw) {
        int a = canProduct(mw);
        if (a > 0) {
            if (a==2) {
                mw = mw.transpose();
            }
            Matrix m = new Matrix();
            for (int i = 0; i < rowsCount(); i++) {
                Vector mRow = new Vector();
                Vector curRow = new Vector(getRow(i));
                for (int j = 0; j < mw.columnsCount(); j++) {
                    Vector curMwCol = mw.getCol(j);
                    mRow.add(curRow.scalarVectorProduct(curMwCol));
                }
                m.add(mRow);
            }
            return m;
        } else {
            throw new IllegalArgumentException("Форма матриц не согласована: " + columnsCount()
                    + " : " + mw.rowsCount());
        }
    }

    private boolean sameDimesion(Matrix a, Matrix b) {
        if ((a.columnsCount() == b.columnsCount())
                && (a.rowsCount() == b.rowsCount())) {
            return true;
        }
        return false;
    }

    private void add(Vector v) {
        set.add(v);
    }

    private void setRow(int i, Vector vector) {
        set.set(i, vector);
    }

    private Vector getRow(int i) {
        return set.get(i);
    }

    private double getValue(int row, int col) {
        return getRow(row).valueAt(col);
    }

    private Vector getCol(int column) {
        Vector v = new Vector();
        for (int i = 0; i < rowsCount(); i++) {
            v.add(getValue(i, column));
        }

        return v;
    }

    public int rowsCount() {
        return set.size();
    }

    public int columnsCount() {
        if (!set.isEmpty()) {
            return set.get(0).count();
        }
        return 0;
    }

    @Override
    public String toString() {
        String s = "";
        for (Vector x : set) {
            for (int i = 0; i < x.count(); i++) {
                s += x.valueAt(i) + " ";
            }
            s += "\n";
        }
        return s;//"Matrix{" + "set=" + set + "rows=" + rowsCount() + "cols=" + columnsCount() + '}';
    }

    private int canProduct(Matrix mw) {
        if (columnsCount() == mw.rowsCount())   {
            return 1;
        }
        if (rowsCount() == mw.columnsCount()) {
            return 2;
        }
        return 0;
    }
}