#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#define MATRIX "MATRIX "
#define a "A"
#define b "B"
#define c "C"
#define newLine "\n"
#define EnterLines "Enter the number of lines: "
#define EnterRows "Enter the number of rows: "
#define SizeB std::cout << MATRIX << b << newLine << EnterLines;

// total - количество выделенной памяти в байтах
// mallocs - сколько раз была выделена память
// frees - сколько раз была освобождена память
int total = 0;
int mallocs = 0;
int frees = 0;

// Макросы для подсчетов total, malloc и frees
#define  malloc(s) (mallocs++, total += (s), malloc((s)))
#define  free(s)   (frees++, free((s)))

// Проверка: является ли ввод пользователя
// числом с плавающей точкой
bool IsValidInput(const std::string& num){
    int i = 0;
    int dotCounter  =0;
    while (num[i] != '\0') {
        if (num[i] == '.' && dotCounter <= 1) {
            dotCounter++;
        } else if (!std::isdigit(num[i]) || dotCounter > 1) {
            return false;
        }
        i++;
    }
    return true;
}


// Функция CreateMatrix создает матрицу, то есть
// выделяет под нее память и заполняет ее значениями,
// которые вводит пользователь
float** CreateMatrix(std::string matrixName, int *linesNum, int *rowsNum) {
    float** X = (float**)malloc(*linesNum * sizeof(float*));
    for (int i = 0; i < *linesNum; i++)
    {
        X[i] = (float*)malloc(*rowsNum * sizeof(float));
        for (int j = 0; j < *rowsNum; j++) {
            std::cout << matrixName << "[" << i + 1 << "][" << j + 1 << "] = ";
            std::string num;
            std::cin >> num;
            while(!IsValidInput(num)){
                std::cout << "Enter the number please!\n";
                std::cin >> num;
            }
            X[i][j] = strtof(num.c_str(), nullptr);
        }
    }
    return X;
}

// Функция freeArr освобождает память, выделенную под массив
void freeArr(float** X, int linesNum) {

    // Очистка памяти (цикл по строкам)
    for (int i = 0; i < linesNum; i++)

        // освобождение памяти под строку
        free(X[i]);
    // Освобождение память массива строк
    free(X);
}

// Функция checkMatrixCompatability проверяет: можно
// ли перемножить две матрицы
bool checkMatrixCompatibility(int rowsA, int linesB) {
    return rowsA == linesB;
}

// Функция Multiply выделяет память под матрицу
// корректной размерности и записывает в нее
// результат перемножения двух матриц
float** Multiply(float** A, float** B, int linesA, int rowsA, int linesB, int rowsB) {
    float** X = (float**)malloc(linesA * sizeof(float*));
    for (int i = 0; i < linesA; i++) {
        X[i] = (float*)malloc(rowsB * sizeof(float));
        for (int j = 0; j < rowsB; j++) {
            X[i][j] = 0;
            for (int k = 0; k < rowsA; k++) {
                X[i][j] += A[i][k] * B[k][j];
            }
        }
    }
    return X;
}

// Функция Show выводит матрицу на экран
void Show(float** X, int lines, int rows) {
    for (int i = 0; i < lines; i++) {
        for (int j = 0; j < rows; j++) {
            std::cout << X[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

// Функция ShowStats выводит на экран
// собранную статистику по total, mallos и frees
void ShowStats() {
    std::cout << "Total memory allocated: " << total << " bytes"<< std::endl;
    std::cout << "Number of allocations: " << mallocs << std::endl;
    std::cout << "Number of frees: " << frees << std::endl;
}

int main() {
    std::cout << "This app calculates A * B = C\n";

    // Creating the matrix A
    float** A;
    int linesNumA, rowsNumA;
    std::cout << MATRIX << a << newLine << EnterLines;
    std::cin >> linesNumA;
    std::cout << EnterRows;
    std::cin >> rowsNumA;
    A = CreateMatrix(a, &linesNumA, &rowsNumA);

    std::cout << std::endl;

    // Creating the matrix B
    float** B;
    int linesNumB, rowsNumB;
    SizeB
    std::cin >> linesNumB;
    std::cout << EnterRows;
    std::cin >> rowsNumB;
    B = CreateMatrix(b, &linesNumB, &rowsNumB);

    // Выводим матрицы A и B на экран
    std::cout << std::endl << "Matrix A:\n";
    Show(A, linesNumA, rowsNumA);
    std::cout << std::endl << "Matrix B:\n";
    Show(B, linesNumB, rowsNumB);

    // Перемножаем матрицы и выводим их на экран в
    // в случае их совместимости
    if (checkMatrixCompatibility(rowsNumA, linesNumB)) {
        float** C;
        int linesNumC = linesNumA, rowsNumC = rowsNumB;
        C = Multiply(A, B, linesNumA, rowsNumA, linesNumB, rowsNumB);
        std::cout << std::endl << "MATRIX C:\n";
        Show(C, linesNumC, rowsNumC);
        freeArr(C, linesNumC);
    } else {
        std::cout <<"Matrixes A and b are not compatible";
    }
    freeArr(A, linesNumA);
    freeArr(B, linesNumB);

    std::cout << std::endl;
    ShowStats();
    return 0;
}