package com.thealgorithms.maths;

import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Objects;
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.stream.IntStream;

/**
 * @author: caos321
 * @date: 31 October 2021 (Sunday)
 */
public class MatrixUtil {

    public static boolean isValid(final BigDecimal[][] matrix) {
        return matrix != null && matrix.length > 0 && matrix[0].length > 0;
    }

    public static boolean hasEqualSizes(
        final BigDecimal[][] matrix1,
        final BigDecimal[][] matrix2
    ) {
        return (
            isValid(matrix1) &&
            isValid(matrix2) &&
            matrix1.length == matrix2.length &&
            matrix1[0].length == matrix2[0].length
        );
    }

    public static boolean canMultiply(
        final BigDecimal[][] matrix1,
        final BigDecimal[][] matrix2
    ) {
        return (
            isValid(matrix1) &&
            isValid(matrix2) &&
            matrix1[0].length == matrix2.length
        );
    }

    public static Optional<BigDecimal[][]> operate(
        final BigDecimal[][] matrix1,
        final BigDecimal[][] matrix2,
        final BiFunction<BigDecimal, BigDecimal, BigDecimal> operation
    ) {
        if (!hasEqualSizes(matrix1, matrix2)) {
            return Optional.empty();
        }

        final int rowSize = matrix1.length;
        final int columnSize = matrix1[0].length;

        final BigDecimal[][] result = new BigDecimal[rowSize][columnSize];

        IntStream
            .range(0, rowSize)
            .forEach(rowIndex ->
                IntStream
                    .range(0, columnSize)
                    .forEach(columnIndex -> {
                        final BigDecimal value1 =
                            matrix1[rowIndex][columnIndex];
                        final BigDecimal value2 =
                            matrix2[rowIndex][columnIndex];

                        result[rowIndex][columnIndex] =
                            operation.apply(value1, value2);
                    })
            );

        return Optional.of(result);
    }

    public static Optional<BigDecimal[][]> add(
        final BigDecimal[][] matrix1,
        final BigDecimal[][] matrix2
    ) {
        return operate(matrix1, matrix2, BigDecimal::add);
    }

    public static Optional<BigDecimal[][]> subtract(
        final BigDecimal[][] matrix1,
        final BigDecimal[][] matrix2
    ) {
        return operate(matrix1, matrix2, BigDecimal::subtract);
    }

    public static Optional<BigDecimal[][]> multiply(
        final BigDecimal[][] matrix1,
        final BigDecimal[][] matrix2
    ) {
        if (!canMultiply(matrix1, matrix2)) {
            return Optional.empty();
        }

        final int size = matrix1[0].length;

        final int matrix1RowSize = matrix1.length;
        final int matrix2ColumnSize = matrix2[0].length;

        final BigDecimal[][] result = new BigDecimal[matrix1RowSize][matrix2ColumnSize];

        IntStream
            .range(0, matrix1RowSize)
            .forEach(rowIndex ->
                IntStream
                    .range(0, matrix2ColumnSize)
                    .forEach(columnIndex ->
                        result[rowIndex][columnIndex] =
                            IntStream
                                .range(0, size)
                                .mapToObj(index -> {
                                    final BigDecimal value1 =
                                        matrix1[rowIndex][index];
                                    final BigDecimal value2 =
                                        matrix2[index][columnIndex];

                                    return value1.multiply(value2);
                                })
                                .reduce(BigDecimal.ZERO, BigDecimal::add)
                    )
            );

        return Optional.of(result);
    }

    public static void assertThat(
        final BigDecimal[][] actual,
        final BigDecimal[][] expected
    ) {
        if (!Objects.deepEquals(actual, expected)) {
            throw new AssertionError(
                String.format(
                    "expected=%s but was actual=%s",
                    Arrays.deepToString(expected),
                    Arrays.deepToString(actual)
                )
            );
        }
    }

    public static void main(final String[] args) {
        {
            final BigDecimal[][] matrix1 = {
                { new BigDecimal(3), new BigDecimal(2) },
                { new BigDecimal(0), new BigDecimal(1) },
            };

            final BigDecimal[][] matrix2 = {
                { new BigDecimal(1), new BigDecimal(3) },
                { new BigDecimal(2), new BigDecimal(0) },
            };

            final BigDecimal[][] actual = add(matrix1, matrix2)
                .orElseThrow(() ->
                    new AssertionError("Could not compute matrix!")
                );

            final BigDecimal[][] expected = {
                { new BigDecimal(4), new BigDecimal(5) },
                { new BigDecimal(2), new BigDecimal(1) },
            };

            assertThat(actual, expected);
        }

        {
            final BigDecimal[][] matrix1 = {
                { new BigDecimal(1), new BigDecimal(4) },
                { new BigDecimal(5), new BigDecimal(6) },
            };

            final BigDecimal[][] matrix2 = {
                { new BigDecimal(2), new BigDecimal(0) },
                { new BigDecimal(-2), new BigDecimal(-3) },
            };

            final BigDecimal[][] actual = subtract(matrix1, matrix2)
                .orElseThrow(() ->
                    new AssertionError("Could not compute matrix!")
                );

            final BigDecimal[][] expected = {
                { new BigDecimal(-1), new BigDecimal(4) },
                { new BigDecimal(7), new BigDecimal(9) },
            };

            assertThat(actual, expected);
        }

        {
            final BigDecimal[][] matrix1 = {
                { new BigDecimal(1), new BigDecimal(2), new BigDecimal(3) },
                { new BigDecimal(4), new BigDecimal(5), new BigDecimal(6) },
                { new BigDecimal(7), new BigDecimal(8), new BigDecimal(9) },
            };

            final BigDecimal[][] matrix2 = {
                { new BigDecimal(1), new BigDecimal(2) },
                { new BigDecimal(3), new BigDecimal(4) },
                { new BigDecimal(5), new BigDecimal(6) },
            };

            final BigDecimal[][] actual = multiply(matrix1, matrix2)
                .orElseThrow(() ->
                    new AssertionError("Could not compute matrix!")
                );

            final BigDecimal[][] expected = {
                { new BigDecimal(22), new BigDecimal(28) },
                { new BigDecimal(49), new BigDecimal(64) },
                { new BigDecimal(76), new BigDecimal(100) },
            };

            assertThat(actual, expected);
        }
    }
}