#include <cstdio>
#include <cstdlib>
#include <ctime>
bool allocate(float ***&p, const int n, const int m, bool &notAllocated, int &count); // Функция выделения памяти под динамический массив
bool fillrandomly(float ***p, const int n, const int m, const int k); // Функция заполнения массива рандомно
bool printTable(float ***p, const int n, const int m, const int k); // Функция вывода значений текущей таблицы
bool MaxExtremumCnt(float ***p, const int n, const int m, const int k, int &row); // Функция поиска максимального числа подряд идущих локальных экстремумов
void chooseTable(int **sizes, int &k, int count, int &n1, int &m1); // Функция выбора текущей таблицы
bool fillKeyboard(float ***p, const int n, const int m, const int k); // Функция считывания и записи элементов массива с клавиатуры
bool fillFile(float ***&p, int **&sizes, int &count); // Функция считывания и записи элементов массива из файла
bool saveInFile(float ***p, const int n, const int m, const int k); // Функция сохранения массива в файл
void exitProgram(); // Подпрограмма завершения программы, потому что нет памяти для выделения на хранение адресов двумерных динамических массивов
int main(){
    srand(time(NULL));
    float ***p = (float***)malloc(sizeof(float**)); // Храним адреса "столбцов", элементы которого указывают на "строки"
    if(p == NULL){
       free(p);
       exitProgram();
    }
    else{
       p[0] = (float**)malloc(sizeof(float*));
       if(p[0] == NULL){
          free(p[0]);
          exitProgram();
       }
       else{
          p[0][0] = (float*)malloc(sizeof(float));
          if(p[0][0] == NULL){
             free(p[0][0]);
             exitProgram();
          }
       }
    }
    int **sizes = (int**)malloc(sizeof(int*)); // Храним размеры двумерных динамических массивов
    if(sizes == NULL){
       free(sizes);
       exitProgram();
    }
    else{
       sizes[0] = (int*)malloc(sizeof(int) * 2);
       if(sizes[0] == NULL){
          free(sizes[0]);
          exitProgram();
       }
    }
    int n, m, n1, m1, count = 0, e = -1, k = -1;
    bool d = false, *f = (bool*)malloc(sizeof(bool));
    if(f == NULL){
       free(f);
       exitProgram();
    }
    else f[0] = false;
    while(e != 8){
       printf("1. Create a table\n");
       printf("2. Fill the table randomly\n");
       printf("3. Fill the table with the keyboard\n");
       printf("4. Create and fill the table from file\n");
       printf("5. Print result\n");
       printf("6. Print table\n");
       printf("7. Save table in file\n");
       printf("8. Exit\n");
       printf("\nChoose your option: ");
       while(!scanf("%d", &e) || !(e >= 1 && e <= 8)){
         printf("Choose your option: ");
         fflush(stdin);
       }
       if(e == 1){
          printf("Enter your n, m: ");
          while(!scanf("%d", &n) || !scanf("%d", &m) || !(n > 0 && m > 0)){
             printf("Enter your n, m: ");
             fflush(stdin);
          }
          bool notAllocated = false;
          bool result = allocate(p, n, m, notAllocated, count);
          if(result){
             if(notAllocated) printf("Error. Could not allocate memory for array!");
             else{
                d = true;
                if(count >= 2){
                   sizes = (int**)realloc(sizes, sizeof(int*) * count);
                   f = (bool*)realloc(f, sizeof(bool) * count);
                   if(sizes == NULL || f == NULL) notAllocated = true;
                   else{
                      sizes[count - 1] = (int*)malloc(sizeof(int) * 2);
                      f[count - 1] = false;
                      if(sizes[count - 1] == NULL) notAllocated = true;
                   }
                }
                if(!notAllocated){
                   sizes[count - 1][0] = n;
                   sizes[count - 1][1] = m;
                   printf("Table created successfully!");
                }
                else printf("Error. Could not allocate memory for array!");
             }
          }
          else printf("Error. Check your parameters.");
       }
       if(e == 2){
          if(d){
             printf("\n");
             chooseTable(sizes, k, count, n1, m1);
             bool result = fillrandomly(p, n1, m1, k);
             if(result){
                if(count >= 2) f = (bool*)realloc(f, sizeof(bool) * count);
                printf("Table successfully filled out!");
                f[k - 1] = true;
             }
             else printf("Error. Check your parameters.");
          }
          else printf("Error. Please, create a table!");
       }
       if(e == 3){
          if(d){
             printf("\n");
             chooseTable(sizes, k, count, n1, m1);
             bool result = fillKeyboard(p, n1, m1, k);
             if(result){
                if(count >= 2) f = (bool*)realloc(f, sizeof(bool) * count);
                printf("Table successfully filled out!");
                f[k - 1] = true;
             }
             else printf("Error. Check your parameters.");
          }
          else printf("Error. Please, create a table!");
       }
       if(e == 4){
           bool result = fillFile(p, sizes, count);
           if(result){
              d = true;
              if(count >= 2) f = (bool*)realloc(f, sizeof(bool) * count);
              f[count - 1] = true;
           }
           else printf("Error. Check your parameters.");
       }
       if(e == 5){
          if(d){
             printf("\n");
             int row = 0;
             chooseTable(sizes, k, count, n1, m1);
             if(f[k - 1]){
               bool result = MaxExtremumCnt(p, n1, m1, k, row);
               if(result){
                if(row == 0) printf("Not found");
                else printf("Ans = %d", row);
               }
               else printf("Error. Check your parameters.");
             }
             else printf("Please, fill the table #%d!", k);
          }
          else printf("Error. Please, create a table!");
       }
       if(e == 6){
          if(d){
             printf("\n");
             chooseTable(sizes, k, count, n1, m1);
             if(f[k - 1]){
               bool result = printTable(p, n1, m1, k);
               if(!result) printf("Error. Check your parameters.");
             }
             else printf("Please, fill the table #%d!", k);
          }
          else printf("Error. Please, create a table!");
       }
       if(e == 7){
          if(d){
             printf("\n");
             chooseTable(sizes, k, count, n1, m1);
             if(f[k - 1]){
               bool result = saveInFile(p, n1, m1, k);
               if(!result) printf("Error. Check your parameters.");
             }
             else printf("Please, fill the table #%d!", k);
          }
          else printf("Please, create a table!");
       }
       if(e == 8){
          if(d){
             for(int i = 0; i < count; ++i){
                char c = '\0';
                if(f[i]){
                  while(!scanf("%c", &c) || c != 'y' && c != 'n'){
                   printf("Do you want save a table #%d? [y / n]: ", i + 1);
                   fflush(stdin);
                  }
                  if(c == 'y'){
                   bool result = saveInFile(p, sizes[i][0], sizes[i][1], i + 1);
                   printf(" ");
                   if(!result) printf("Could not save table #%d.\nCheck your parameters.", i + 1);
                  }
                }
                for(int j = 0; j < sizes[i][0]; ++j) free(p[i][j]);
                free(p[i]);
                free(sizes[i]);
             }
             free(sizes);
             free(f);
          }
          printf("Goodbye!");
       }
       k = -1;
       printf("\n\n");
    }
    system("pause");
    return 0;
}
bool allocate(float ***&p, const int n, const int m, bool &notAllocated, int &count){
    // Функция создает двумерный динамический массив заданных пользователем размеров
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // n - Число строк двумерного динамического массива (Вводится пользователем)
    // m - Число столбцов двумерного динамического массива (Вводится пользователем)
    // notAllocated - булева переменная, которая отслеживает -- выделилась ли память под массив или нет
    // count - счетчик для записи в массив p, где мы храним адреса "столбцов", элементы которого указывают на "строки"
    // На выходе:
    // Код завершения с проверкой на успех выделения памяти под двумерный динамический массив
    bool result = true;
    if(n > 0 && m > 0){
        notAllocated = false;
        float **a = (float**)malloc(sizeof(float*) * n);
        if(a == NULL){
           notAllocated = true;
           free(a);
        }
        else{
           for(int i = 0; i < n && !notAllocated; ++i){
              a[i] = (float*)malloc(sizeof(float) * m);
              if(a[i] == NULL) notAllocated = true;
           }
           if(notAllocated){
              for(int i = 0; i < n; ++i) free(a[i]);
              free(a);
           }
           else{
              if(count >= 1){
                 p = (float***)realloc(p, sizeof(float**) * (count + 1));
                 if(p == NULL){
                    notAllocated = true;
                    free(p);
                 }
              }
              if(!notAllocated){
                 p[count] = a;
                 ++count;
              }
           }
        }
    }
    else result = false;
    return result;
}
bool fillrandomly(float ***p, const int n, const int m, const int k){
    // Функция заполнения текущего двумерного динамического массива случайными числами
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // n - Число строк двумерного динамического массива (Вводится пользователем)
    // m - Число столбцов двумерного динамического массива (Вводится пользователем)
    // k - Индекс таблицы. К p обращаемся в виде p[tabIndex][i][j], где tabIndex -- одна из count таблиц
    // На выходе:
    // Код завершения с заполнением двумерного динамического массива
    bool result = true;
    if(n > 0 && m > 0 && k >= 1){
      for(int i = 0; i < n; ++i)
          for(int j = 0; j < m; ++j)
             p[k - 1][i][j] = rand() % 10 - 5;
    }
    else result = false;
    return result;
}
bool fillKeyboard(float ***p, const int n, const int m, const int k){
    // Функция заполнения текущего двумерного динамического массива с клавиатуры
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // n - Число строк двумерного динамического массива (Вводится пользователем)
    // m - Число столбцов двумерного динамического массива (Вводится пользователем)
    // k - Индекс таблицы. К p обращаемся в виде p[tabIndex][i][j], где tabIndex -- одна из count таблиц
    // На выходе:
    // Код завершения с заполнением двумерного динамического массива
    bool result = true;
    if(n > 0 && m > 0 && k >= 1){
        printf("Enter your values:\n");
        for(int i = 0; i < n; ++i){
           for(int j = 0; j < m; ++j){
              while(!scanf("%f", &p[k - 1][i][j])){
                 printf("Enter your correct value:\n");
                 fflush(stdin);
              }
           }
        }
    }
    else result = false;
    return result;
}
bool fillFile(float ***&p, int **&sizes, int &count){
    // Функция заполнения текущего двумерного динамического массива из файла
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // sizes - Размерность каждого выделенного двумерного динамического массива
    // count - Число текущих успешно выделенных двумерных динамических массивов
    // На выходе:
    // Код завершения с заполнением двумерного динамического массива
    bool result = true;
    if(count >= 0){
       char filename[80];
       printf("Enter your filename: ");
       scanf("%s", &filename);
       FILE *file = fopen(filename, "r");
       if(file == NULL) printf("Could not open file");
       else{
          int cnt = 0, rowsFile, colsFile;
          bool error = false;
          if(!fscanf(file, "%d", &rowsFile) || !fscanf(file, "%d", &colsFile)) error = true;
          else cnt += 2;
          if(error) printf("Error. Check your sizes in file.");
          else{
             bool notAllocated = false;
             bool result = allocate(p, rowsFile, colsFile, notAllocated, count);
             if(result){
               if(!notAllocated){
                 if(count >= 2) sizes = (int**)realloc(sizes, sizeof(int*) * count);
                 if(sizes == NULL){
                    notAllocated = true;
                    printf("Error. Could not allocate memory for an array!");
                    free(sizes);
                 }
                 else sizes[count - 1] = (int*)malloc(sizeof(int) * 2);
                 if(sizes[count - 1] == NULL){
                    notAllocated = true;
                    printf("Error. Could not allocate memory for an array!");
                    free(sizes[count - 1]);
                 }
                 else{
                    float current = 0.0;
                    for(int i = 0; i < rowsFile && !error; ++i){
                      for(int j = 0; j < colsFile && !error; ++j){
                        if(!fscanf(file, "%f", &p[count - 1][i][j])) error = true;
                        else ++cnt;
                      }
                    }
                    if(error || cnt < (rowsFile * colsFile + 2)){
                       sizes = (int**)realloc(sizes, sizeof(int*) * (count - 1));
                       free(sizes[count - 1]);
                       printf("Error. Check your file.");
                    }
                    else{
                       sizes[count - 1][0] = rowsFile;
                       sizes[count - 1][1] = colsFile;
                       printf("Table successfully filled out!");
                    }
                 }
               }
               else printf("Error. Could not allocate memory for an array!");
             }
             else printf("Error. Check your parameters");
          }
       }
       fclose(file);
    }
    else result = false;
    return result;
}
bool saveInFile(float ***p, const int n, const int m, const int k){
    // Функция сохранения в файл выбранного двумерного динамического массива
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // n - Число строк двумерного динамического массива (Вводится пользователем)
    // m - Число столбцов двумерного динамического массива (Вводится пользователем)
    // k - Индекс таблицы. К p обращаемся в виде p[tabIndex][i][j], где tabIndex -- одна из count таблиц
    // На выходе:
    // Код завершения с сохранением двумерного динамического массива в файл, который спрашивается у пользователя
    bool result = true;
    if(n > 0 && m > 0 && k >= 1){
        char filename[80];
        printf("Enter your filename: ");
        scanf("%s", &filename);
        FILE *file = fopen(filename, "w+");
        if(file == NULL) printf("Could not open file.");
        else{
           fprintf(file, "%d %d %c", n, m, '\n');
           for(int i = 0; i < n; ++i){
              for(int j = 0; j < m; ++j)
                 fprintf(file, "%6.2f ", p[k - 1][i][j]);
              fprintf(file, "%c", '\n');
           }
           printf("Table successfully saved!");
        }
        fclose(file);
    }
    else result = false;
    return result;
}
bool printTable(float ***p, const int n, const int m, const int k){
    // Функция вывода текущей таблицы
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // n - Число строк двумерного динамического массива (Вводится пользователем)
    // m - Число столбцов двумерного динамического массива (Вводится пользователем)
    // k - Индекс таблицы. К p обращаемся в виде p[tabIndex][i][j], где tabIndex -- одна из count таблиц
    // На выходе:
    // Код завершения с выводом текущей таблицы
    bool result = true;
    if(n > 0 && m > 0 && k >= 1){
       printf("\n");
       for(int i = 0; i < n; ++i){
          for(int j = 0; j < m; ++j)
             printf("%6.2f ", p[k - 1][i][j]);
          printf("\n");
       }
    }
    else result = false;
    return result;
}
bool MaxExtremumCnt(float ***p, const int n, const int m, int k, int &row){
    // Функция поиска строки, в которой максимальное число подряд идущих строгих локальных экстремумов
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // n - Число строк двумерного динамического массива (Вводится пользователем)
    // m - Число столбцов двумерного динамического массива (Вводится пользователем)
    // k - Индекс таблицы. К p обращаемся в виде p[tabIndex][i][j], где tabIndex -- одна из count таблиц
    // row - результирующая строка, в которой максимальное число подряд идущих строгих локальных экстремумов
    // На выходе:
    // Код завершения и результирующая строка, в которой максимальное число подряд идущих строгих локальных экстремумов
    bool result = true;
    if(n > 0 && m > 0 && k >= 1){
       float current = 0.0f, prev = 0.0f, next = 0.0f;
       int count = 0, r = 0;
       for(int i = 0; i < n; ++i){
          for(int j = 1; j < m - 1; ++j){
             prev = p[k - 1][i][j - 1];
             current = p[k - 1][i][j];
             next = p[k - 1][i][j + 1];
             if((current > prev && current > next) || (current < prev && current < next)) ++count;
             else{
                if(r < count){
                   row = i + 1;
                   r = count;
                   count = 0;
                }
             }
          }
          if(r < count){
             row = i + 1;
             r = count;
          }
          count = 0;
       }
    }
    else result = false;
    return result;
}
void chooseTable(int **sizes, int &k, int count, int &n1, int &m1){
    // Подпрограмма выбора таблицы из всех возможных-созданных
    // На входе:
    // p - храним адреса "столбцов", элементы которого указывают на "строки"
    // sizes - Размерность каждого выделенного двумерного динамического массива
    // count - Число текущих успешно выделенных двумерных динамических массивов
    // n1, m1 - переменные, для передачи значений числа строк и столбцов у выбранной таблицы (соответственно)
    // k - номер выбранной таблицы
    // На выходе:
    // Значения для n1, m1 - число строк и стобцов исходной таблицы
    while(k == -1){
       for(int i = 0; i < count; ++i)
          printf("%d. Table #%d\n", i + 1, i + 1);
          printf("Choose your table: ");
       while(!scanf("%d", &k) || !(k >= 1 && k <= count)){
          printf("Choose your table: ");
          fflush(stdin);
       }
    }
    n1 = sizes[k - 1][0];
    m1 = sizes[k - 1][1];
}
void exitProgram(){
    // Подпрограмма выхода из программы в случае, если нет памяти на выделение главной части программы, работа без которой невозможна.
    // На входе: ничего
    // На выходе: Уведомление о недостаточности памяти для выделения основных частей программы.
    printf("Error. Could not allocate memory for create an main array!\n");
    getchar();
    exit(0);
}