#include "pch.h"
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <windows.h>
#include <string.h>

#define SC system("cls");
#define SP system("pause");
#define TZP printf("\n\aТаблица заказов пуста\n");
#define TPP printf("\n\aТаблица продукции пуста\n");
#define gets gets_s
void menu(void); // Меню выбора администратора либо пользователя
void menuAdm(void); // Меню администратора
void menuPol(void);// Меню пользователя
void menuSKR(void); // Меню ввода продукции либо заказа
void menuexit(void); // Меню выхода
void exitProg(void); // функция закрытия программы
void vvod(void); // функция ввода
void zapis(void);  // функция записи продукции
void vvodZak(void); // функция ввода заказа
void menusort(void); // меню сортировки
void menusearch(void);// меню поиска
void menuvivod(void); // мею вывода
void sort(void); // функция сортировки продукции
void sortZak(void); // функция сортировки заказов
void searchZak(void); // функция поиска заказов
void search(void); // функция поиска продукции
void change(void); // функция изменения продукции
void changemenu(void); // меню изменения
void changeZak(void); // функция изменения заказов
void deletee(void); // функция удаления продукции
void deleteemenu(void); // меню удаления
void deleteeZak(void); //функция удаления заказов
void deleteePol(void); // функция удаления пользователей
void vivodProd(void); // функция вывода продукции
void vivodZakaz(void); // функция вывода заказов
void zapisZak(void); // функция записи заказов
void vhodADMIN(void); // функция отвечающая за ввод логина и пароля для администратора
void vhod(void); // функция отвещающая за ввод логина и пароля для пользователя
void schitatPIP(void);// функция считывания пользователей из бинарного файла
void zapisatPIP(void);// функция записи новых пользователей в бинарный файл
void dobavitPIP(void);// функция добавления новых пользователей
void loginPol(void); // функция выбора для пользователя
void vivodtopProd(void); // функция вывода топ продукции
void vivodtopZakaz(void);// функция вывода топ заказов
int structsize = 0, i, j, k, kol, q, intbuf, res, structsize1 = 0, structsize2 = 0, bal, vib = 0;
char choice, buffer[30], check, block;

struct strct {
    char dataa[30];
};

struct struct1 {
    struct strct data;
    char prod[30], kolv[30];
    int sum, sumZa;

};

struct struct1 client[50];
struct struct1 tmp;

struct struct2 {
    struct strct dataz;
    char prodz[30], kolvz[30], adres[30];
    int stom;

};

struct struct2 clp[50];
struct struct2 ppa;


struct struct3 {
    char login[30], parol[30];
    char role[30];
};
struct struct3 pip[50];
int pipsize = 0;



FILE *file, *file2, *file3;
FILE *users;

void schitatPIP() {
    users = fopen("users", "rb");
    fread(&pipsize, sizeof(int), 1, users);
    for (int i = 0; i < pipsize; i++)
        fread(&pip[i], sizeof(struct struct3), 1, users);
    fclose(users);
    getchar();
}

void zapisatPIP() {
    users = fopen("users", "w+b");
    fwrite(&pipsize, sizeof(int), 1, users);
    for (int i = 0; i < pipsize; i++)
        fwrite(&pip[i], sizeof(struct struct3), 1, users);
    fclose(users);
    getchar();
}

void dobavitPIP() {
    struct struct3 noviy_pip;
    strcpy(noviy_pip.role, "user");
    printf("Введите логин\n");
    fflush(stdin);
    gets(noviy_pip.login);
    gets(noviy_pip.login);
    printf("Введите пароль\n");
    fflush(stdin);
    gets(noviy_pip.parol);
    pip[pipsize] = noviy_pip;
    pipsize += 1;
    zapisatPIP();
}

void udalitPIP() {
    char login[30];
    printf("Введите логин\n");
    fflush(stdin);
    gets(login);
    gets(login);
    int i, j;
    for (i = 0; i < pipsize; i++) {
        if (strcmp(pip[i].login, login) == 0) {
            for (j = i; j < pipsize - 1; j++) {
                pip[j] = pip[j + 1];
            }
            zapisatPIP();
            return;
        }
    }
    printf("Ошибка ввода\n");
    system("pause");
}

void vhodADMIN() {
    char login[30], parol[30], role[30];
    strcpy(role, "admin");
    int i;
    schitatPIP();
    printf("Введите логин\n");
    fflush(stdin);
    gets(login);
    gets(login);
    printf("Введите пароль\n");
    fflush(stdin);
    gets(parol);
    for (i = 0; i < pipsize; i++) {
        if (strcmp(pip[i].login, login) == 0 && strcmp(pip[i].parol, parol) == 0 && strcmp(pip[i].role, role) == 0) {
            SC
                menuAdm();
            system("cls");
            return;
        }
    }
    printf("Ошибка входа\n");
    system("pause");
}

void sort() {
    struct struct1 tmp1;
    int temp, i, j;
    for (i = 0; i < structsize - 1; i++) {
        temp = i;
        for (j = i + 1; j < structsize; j++) {
            if (client[j].sumZa > client[temp].sumZa) {
                temp = j;
            }
        }
        tmp1 = client[temp];
        client[temp] = client[i];
        client[i] = tmp1;
    }
    return;
}

void vhod() {
    char login[30], parol[30], role[30];
    strcpy(role, "user");
    int i;
    schitatPIP();
    printf("Введите логин\n");
    fflush(stdin);
    gets(login);
    gets(login);
    printf("Введите пароль\n");
    fflush(stdin);
    gets(parol);
    for (i = 0; i < pipsize; i++) {
        if (strcmp(pip[i].login, login) == 0 && strcmp(pip[i].parol, parol) == 0 && strcmp(pip[i].role, role) == 0) {
            SC
                menuPol();
            system("cls");
            return;
        }
    }
    printf("Ошибка входа\n");
    system("pause");
}

void menu(void) {
    while (1) {
        schitat();
        schitatPIP();
        schitatZak();
        printf("1)Войти как администратор\n2)Войти как пользователь\n0)Выйти из программы\n");
        scanf("%c", &block);
        switch (block)
        {
        case '1':
            SC
                vhodADMIN();
            system("cls");
            break;
        case '2':
            SC
                loginPol();
            system("cls");
            break;
        case '0':
            SC
                exitProg();
            system("cls");
            break;
            return;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void menuAdm(void) {
    while (1) {
        printf("МЕНЮ АДМИНИСТРАТОРА\n1)Меню ввода данных\n2)Меню сортировки\n3)Меню поиска\n4)Меню изменения\n5)Меню удаления\n6)меню вывода\n7)Управление пользователями\n0)Выйти\n");
        scanf(" %c", &choice);
        switch (choice)
        {
        case '1':
            SC
                menuSKR();
            system("cls");
            break;
        case '2':
            SC
                if (structsize < 1 && structsize1 < 1) {
                    printf("Ведите данные!\n");
                    SP
                        SC
                        break;
                }
            SC
                menusort();
            SC
                break;
        case '3':
            SC
                if (structsize < 1 && structsize1 < 1) {
                    printf("Ведите данные!\n");
                    SP
                        SC
                        break;
                }
            SC
                menusearch();
            SC
                break;
        case '4':
            SC
                if (structsize < 1 && structsize1 < 1) {

                    printf("Ведите данные!\n");
                    SP
                        SC
                        break;
                }
            SC
                changemenu();
            SP
                SC
                break;
        case '5':
            SC
                if (structsize < 1 && structsize1 < 1) {

                    printf("Ведите данные!\n");
                    SP
                        SC
                        break;
                }
            SC
                deleteemenu();
            SP
                SC
                break;
        case '6':
            SC
                if (structsize < 1 && structsize1 < 1) {

                    printf("Ведите данные!\n");
                    SP
                        SC
                        break;
                }
            menuvivod();
            SP
                SC
                break;
        case '7':
            deleteePol();
            system("cls");
            break;
        case '0':
            zapis();
            zapisatPIP();
            zapisZak();
            SC
                menuexit();
            system("cls");
            break;
        default:
            system("cls");
            break;
        }
    }
    return;
}

void vvod(void)
{
    printf("#%d\n", structsize + 1);
    printf("Тип продукции\n");
    fflush(stdin);
    gets(client[structsize].prod);
    gets(client[structsize].prod);
    printf("Количество\n");
    fflush(stdin);
    gets(client[structsize].kolv);
    printf("Цена за всю партию\n");
    scanf("%d", &client[structsize].sum);
    printf("Цена за десток\n");
    scanf("%d", &client[structsize].sumZa);
    printf("Дата последнего изменения\n");
    fflush(stdin);
    gets(client[structsize].data.dataa);
    gets(client[structsize].data.dataa);
    char proverka[30];
    int data[30];
    if (client[structsize].data.dataa[2] != '.' || client[structsize].data.dataa[5] != '.' || strlen(client[structsize].data.dataa) != 10) {
        printf("Ошибка ввода\n");
        system("pause");
        return;
    }
    proverka[0] = client[structsize].data.dataa[0];
    proverka[1] = client[structsize].data.dataa[1];
    data[0] = atoi(proverka);
    for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
    proverka[0] = client[structsize].data.dataa[3];
    proverka[1] = client[structsize].data.dataa[4];
    data[1] = atoi(proverka);
    for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
    proverka[0] = client[structsize].data.dataa[6];
    proverka[1] = client[structsize].data.dataa[7];
    proverka[2] = client[structsize].data.dataa[8];
    proverka[3] = client[structsize].data.dataa[9];
    data[2] = atoi(proverka);
    if (data[0] > 31 || data[0] < 0 || data[1]>12 || data[1] < 0 || data[2]>2020 || data[2] < 2019) {
        printf("Ошибка ввода\n");
        system("pause");
        return;
    }
    structsize++;
    while (1) {
        printf("\n1)продолжить ввод\n2)прекратить\n");
        scanf(" %c", &choice);
        switch (choice) {
        case '1':

            printf("#%d\n", structsize + 1);
            printf("Тип продукции\n");
            fflush(stdin);
            gets(client[structsize].prod);
            gets(client[structsize].prod);
            printf("Количество\n");
            fflush(stdin);
            gets(client[structsize].kolv);
            printf("Цена за всю партию\n");
            scanf("%d", &client[structsize].sum);
            printf("Цена за десток\n");
            scanf("%d", &client[structsize].sumZa);
            printf("Дата последнего изменения\n");
            fflush(stdin);
            gets(client[structsize].data.dataa);
            gets(client[structsize].data.dataa);
            char proverka[30];
            int data[3];
            if (client[structsize].data.dataa[2] != '.' || client[structsize].data.dataa[5] != '.' || strlen(client[structsize].data.dataa) != 10) {
                printf("Ошибка ввода\n");
                system("pause");
                return;
            }
            proverka[0] = client[structsize].data.dataa[0];
            proverka[1] = client[structsize].data.dataa[1];
            data[0] = atoi(proverka);
            for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
            proverka[0] = client[structsize].data.dataa[3];
            proverka[1] = client[structsize].data.dataa[4];
            data[1] = atoi(proverka);
            for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
            proverka[0] = client[structsize].data.dataa[6];
            proverka[1] = client[structsize].data.dataa[7];
            proverka[2] = client[structsize].data.dataa[8];
            proverka[3] = client[structsize].data.dataa[9];
            data[2] = atoi(proverka);
            if (data[0] > 31 || data[0] < 0 || data[1]>12 || data[1] < 0 || data[2]>2020 || data[2] < 2019) {
                printf("Ошибка ввода\n");
                system("pause");
                return;
            }
            structsize++;
            break;
        case '2':
            zapis();
            return;
        default:
            system("cls");
            break;
        }
    }
    return;
}

void loginPol(void) {
    while (1) {
        printf("1)Аккаунт существует\n");
        printf("2)Создать новый аккаунт\n");
        printf("0)Назад\n");
        scanf("%c", &block);
        switch (block)
        {
        case '1':
            SC
                vhod();
            system("cls");
            break;
        case '2':
            SC
                dobavitPIP();
            system("cls");
            break;
        case '0':
            SC
                return;
        default:
            system("cls");
            break;
        }
    }
}

void vvodZak(void)
{
    int pro;
    char proverka[30];
    int data[3];
    data[0]=0;
    data[1]=0;
    data[2]=0;
    printf("#%d\n", structsize1 + 1);
    printf("Тип продукции\n");
    fflush(stdin);
    gets(clp[structsize1].prodz);
    gets(clp[structsize1].prodz);
    printf("Нужное количество(десятки)\n");
    fflush(stdin);
    gets(clp[structsize1].kolvz);
    printf("Стоимость заказа\n");
    scanf("%d", &clp[structsize1].stom);
    printf("Дата добавления заказа:\n");
    fflush(stdin);
    gets(clp[structsize1].dataz.dataa);
    gets(clp[structsize1].dataz.dataa);
    if (clp[structsize1].dataz.dataa[2] != '.' || clp[structsize1].dataz.dataa[5] != '.' || strlen(clp[structsize1].dataz.dataa) != 10) {
        printf("Ошибка ввода1\n");
        system("pause");
        return;
    }
    proverka[0] = clp[structsize1].dataz.dataa[0];
    proverka[1] = clp[structsize1].dataz.dataa[1];
    data[0] = atoi(proverka);
    for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
    proverka[0] = clp[structsize1].dataz.dataa[3];
    proverka[1] = clp[structsize1].dataz.dataa[4];
    data[1] = atoi(proverka);
    for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
    proverka[0] = clp[structsize1].dataz.dataa[6];
    proverka[1] = clp[structsize1].dataz.dataa[7];
    proverka[2] = clp[structsize1].dataz.dataa[8];
    proverka[3] = clp[structsize1].dataz.dataa[9];
    data[2] = atoi(proverka);
    if (data[0] > 31 || data[0] < 0 || data[1]>12 || data[1] < 0 || data[2]>2020 || data[2] < 2019) {
        printf("Ошибка ввода2\n");
        system("pause");
        return;
    }
    printf("Адрес:\n ");
    fflush(stdin);
    gets(clp[structsize1].adres);
    structsize1++;
    while (1) {
        printf("\n1)продолжить ввод\n2)прекратить\n");
        scanf(" %c", &choice);
        switch (choice) {
        case '1':
            data[0]=0;
            data[1]=0;
            data[2]=0;
            printf("#%d\n", structsize1 + 1);
            printf("Тип продукции\n");
            fflush(stdin);
            gets(clp[structsize1].prodz);
            gets(clp[structsize1].prodz);
            printf("Нужное количество(десятки)\n");
            fflush(stdin);
            gets(clp[structsize1].kolvz);
            printf("Стоимость заказа\n");
            scanf("%d", &clp[structsize1].stom);
            printf("Дата добавления заказа:\n");
            fflush(stdin);
            gets(clp[structsize1].dataz.dataa);
            gets(clp[structsize1].dataz.dataa);
            if (clp[structsize1].dataz.dataa[2] != '.' || clp[structsize1].dataz.dataa[5] != '.' || strlen(clp[structsize1].dataz.dataa) != 10) {
                printf("Ошибка ввода3\n");
                system("pause");
                return;
            }
            proverka[0] = clp[structsize1].dataz.dataa[0];
            proverka[1] = clp[structsize1].dataz.dataa[1];
            data[0] = atoi(proverka);
            for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
                proverka[pro]=' ';
            }
            proverka[0] = clp[structsize1].dataz.dataa[3];
            proverka[1] = clp[structsize1].dataz.dataa[4];
            data[1] = atoi(proverka);
            for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
                proverka[pro]=' ';
            }
            proverka[0] = clp[structsize1].dataz.dataa[6];
            proverka[1] = clp[structsize1].dataz.dataa[7];
            proverka[2] = clp[structsize1].dataz.dataa[8];
            proverka[3] = clp[structsize1].dataz.dataa[9];
            data[2] = atoi(proverka);
            if (data[0] > 31 || data[0] < 0 || data[1]>12 || data[1] < 0 || data[2]>2020 || data[2] < 2019) {
                printf("Ошибка ввода4\n");
                system("pause");
                return;
            }
            printf("Адрес:\n ");
            fflush(stdin);
            gets(clp[structsize1].adres);
            structsize1++;
            break;
        case '2':
            zapisZak();
            return;
        default:
            system("cls");
            break;
        }
    }
    return;
}

void menusort(void)
{
    while (1) {
        printf("1)Сортировать продукцию\n2)Сортировать заказы\n0)Выйти\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            SC
                sort();
            system("cls");
            break;
        case '2':
            SC
                sortZak();
            system("cls");
            break;
        case '0':
            return;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void menusearch(void)
{
    while (1) {
        printf("1)Поиск продукции\n2)Поиск заказов\n0)Выйти\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            SC
                search();
            SP
                system("cls");
            break;
        case '2':
            SC
                searchZak();
            SP
                system("cls");
            break;
        case '0':
            return;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void menuSKR(void)
{
    while (1) {
        printf("1)Ввести продукцию\n2)Ввести заказы\n0)Выйти\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            SC
                vvod();
            system("cls");
            break;
        case '2':
            SC
                vvodZak();
            system("cls");
            break;
        case '0':
            return;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void sortZak(void)
{
    struct struct2 tmp;
    int temp, i, j;
    for (i = 0; i < structsize1 - 1; i++) {
        temp = i;
        for (j = i + 1; j < structsize1; j++) {
            if (clp[j].stom > clp[temp].stom) {
                temp = j;
            }
        }
        tmp = clp[temp];
        clp[temp] = clp[i];
        clp[i] = tmp;
    }
    return;
}

void zapis(void)
{
    FILE *clients;
    clients = fopen("clients", "w+b");
    fwrite(&structsize1, sizeof(int), 1, clients);
    for (int i = 0; i < structsize1; i++)
        fwrite(&client[i], sizeof(struct struct1), 1, clients);
    fclose(clients);
    getchar();
}
void schitat(void)
{
    FILE *clients;
    clients = fopen("clients", "rb");
    fread(&structsize1, sizeof(int), 1, clients);
    for (int i = 0; i < structsize1; i++)
        fread(&client[i], sizeof(struct struct1), 1, clients);
    fclose(clients);
    getchar();
}

void zapisZak(void) {
    FILE *zaks;
    zaks = fopen("zaks", "w+b");
    fwrite(&structsize1, sizeof(int), 1, zaks);
    for (int i = 0; i < structsize1; i++)
        fwrite(&clp[i], sizeof(struct struct2), 1, zaks);
    fclose(zaks);
    getchar();
}
void schitatZak(void) {
    FILE *zaks;
    zaks = fopen("zaks", "r+b");
    fread(&structsize1, sizeof(int), 1, zaks);
    for (int i = 0; i < structsize1; i++)
        fread(&clp[i], sizeof(struct struct2), 1, zaks);
    fclose(zaks);
    getchar();
}
void deleteePol(void)
{
    SC
        while (1) {
            printf("1)Создать нового пользователя\n");
            printf("2)Удалить пользователя\n");
            printf("3)Изменить пароль\n");
            printf("0)Назад\n");
            scanf(" %c", &block);
            switch (block)
            {
            case '1':
                SC

                    dobavitPIP();
                SP
                    system("cls");
                break;
            case '2':
                SC
                    schitatPIP();
                    udalitPIP();
                SP
                    system("cls");
                break;
            case '0':
                return;
            default:
                system("cls");
                break;
            }
        }
    system("cls");
    SP
}

void deleteemenu(void)
{
    while (1) {
        printf("1)Удалить продукцию\n2)Удалить заказ\n0)Выйти\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            SC
                deletee();
            SP
                system("cls");
            break;
        case '2':
            SC
                deleteeZak();
            SP
                system("cls");
            break;
        case '0':
            return;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void search(void) {
    vivodProd();
    printf("Искать\n1)Тип продукции\n2)Количество\n3)Цену\n4)Дату посл. изменения\n");
    scanf(" %c", &choice);
    char searchvar[30];
    int flag = 0, searchint;
    switch (choice)
    {
    case '1':
        kol = 0;
        printf("?-> ");
        fflush(stdin);
        gets(searchvar);
        gets(searchvar);
        puts("");
        for (i = 0; i < structsize; i++) {
            if (strcmp(searchvar, client[i].prod) == 0) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\n\n", client[i].prod, client[i].kolv, client[i].sum, client[i].data.dataa);
            }
        }
        break;
    case '2':
        kol = 0;
        printf("?-> ");
        fflush(stdin);
        gets(searchvar);
        gets(searchvar);
        puts("");
        for (i = 0; i < structsize; i++) {
            if (strcmp(searchvar, client[i].kolv) == 0) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\n\n", client[i].prod, client[i].kolv, client[i].sum, client[i].data.dataa);
            }
        }
        break;
    case '3':
        kol = 0;
        printf("?-> ");
        scanf("%d", &searchint);
        puts("");
        for (i = 0; i < structsize; i++) {
            if (searchint == client[i].sum) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\n\n", client[i].prod, client[i].kolv, client[i].sum, client[i].data.dataa);
            }
        }
        break;
    case '4':
        kol = 0;
        printf("?-> ");
        fflush(stdin);
        gets(searchvar);
        gets(searchvar);
        puts("");
        for (i = 0; i < structsize; i++) {
            if (strcmp(searchvar, client[i].data.dataa) == 0) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\n\n", client[i].prod, client[i].kolv, client[i].sum, client[i].data.dataa);
            }
        }
        break;
    default:
        system("cls");
        break;
    }
    return;
}

void searchZak(void) {
    vivodZakaz();
    printf("Искать\n1)Тип продукции\n2)Количество\n3)Цену\n4)Дату посл. изменения\n5)Адрес\n0)Выход\n");
    scanf(" %c", &choice);
    char searchvar2[30];
    int flag2 = 0, searchint2;
    switch (choice)
    {
    case '1':
        kol = 0;
        printf("?-> ");
        fflush(stdin);
        gets(searchvar2);
        gets(searchvar2);
        puts("");
        for (i = 0; i < structsize1; i++) {
            if (strcmp(searchvar2, clp[i].prodz) == 0) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\nАдрес %s\n\n", clp[i].prodz, clp[i].kolvz, clp[i].stom, clp[i].dataz.dataa, clp[i].adres);
            }
        }
        break;
    case '2':
        kol = 0;
        printf("?-> ");
        fflush(stdin);
        gets(searchvar2);
        gets(searchvar2);
        puts("");
        for (i = 0; i < structsize1; i++) {
            if (strcmp(searchvar2, clp[i].kolvz) == 0) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\nАдрес %s\n\n", clp[i].prodz, clp[i].kolvz, clp[i].stom, clp[i].dataz.dataa, clp[i].adres);
            }
        }
        break;
    case '3':
        kol = 0;
        printf("?-> ");
        scanf("%d", &searchint2);
        puts("");
        for (i = 0; i < structsize1; i++) {
            if (searchint2 == clp[i].stom) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\nАдрес %s\n\n", clp[i].prodz, clp[i].kolvz, clp[i].stom, clp[i].dataz.dataa, clp[i].adres);
            }
        }
        break;
    case '4':
        kol = 0;
        printf("?-> ");
        fflush(stdin);
        gets(searchvar2);
        gets(searchvar2);
        puts("");
        for (i = 0; i < structsize1; i++) {
            if (strcmp(searchvar2, clp[i].dataz.dataa) == 0) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\nАдрес %s\n\n", clp[i].prodz, clp[i].kolvz, clp[i].stom, clp[i].dataz.dataa, clp[i].adres);
            }
        }
        break;
    case '5':
        kol = 0;
        printf("?-> ");
        fflush(stdin);
        gets(searchvar2);
        gets(searchvar2);
        puts("");
        for (i = 0; i < structsize1; i++) {
            if (strcmp(searchvar2, clp[i].adres) == 0) {
                kol++;
                printf("Продукция %s\nКоличество %s\nЦена %d\nДата посл. изменения %s\nАдрес %s\n\n", clp[i].prodz, clp[i].kolvz, clp[i].stom, clp[i].dataz.dataa, clp[i].adres);
            }
        }
        break;
    case '0':
        return;
    default:
        system("cls");
        break;
    }
    return;
}

void change(void) {
    vivodProd();
    printf("\nИзменить\n");
    scanf("%d", &i);
    if (i<1 || i>structsize) {
        printf("ошибка\n");
        return;
    }
    printf("1)Продукция \n2)Количество\n3)Цена\n4)Дата\n");
    scanf(" %c", &choice);
    switch (choice)
    {
    case '1':
        printf("Введите продукцию\n");
        fflush(stdin);
        gets(client[i - 1].prod);
        gets(client[i - 1].prod);
        break;
    case '2':
        printf("Введите количество\n ");
        fflush(stdin);
        gets(client[i - 1].kolv);
        gets(client[i - 1].kolv);
        break;
    case '3':
        printf("Введите цену\n ");
        scanf("%d", &client[i - 1].sum);
        break;
    case '4':
        printf("Введите дату\n");
        fflush(stdin);
        gets(client[i - 1].data.dataa);
        gets(client[i - 1].data.dataa);
        break;
    default:
        system("cls");
        break;
    }
    return;
}

void changemenu(void)
{
    while (1) {
        printf("1)Изменить продукцию\n2)Изменить заказы\n0)Выйти\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            SC
                change();
            system("cls");
            break;
        case '2':
            SC
                changeZak();
            system("cls");
            break;
        case '0':
            return;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void changeZak(void)
{
    vivodZakaz();
    char proverka[30];
    int data[3];
    printf("\nИзменить\n");
    scanf("%d", &i);
    if (i<1 || i>structsize1) {
        printf("ошибка\n");
        return;
    }
    printf("1)Продукция \n2)Количество\n3)Цена\n4)Дата\n5)Адрес\n0)Выход");
    scanf(" %c", &choice);
    switch (choice)
    {
    case '1':
        printf("Введите продукцию\n");
        fflush(stdin);
        gets(clp[i - 1].prodz);
        gets(clp[i - 1].prodz);
        break;
    case '2':
        printf("Введите количество\n ");
        fflush(stdin);
        gets(clp[i - 1].kolvz);
        gets(clp[i - 1].kolvz);
        break;
    case '3':
        printf("Введите цену\n ");
        scanf("%d", &clp[i - 1].stom);
        break;
    case '4':
        printf("Введите дату\n");
        fflush(stdin);
        gets(clp[i - 1].dataz.dataa);
        gets(clp[i - 1].dataz.dataa);
        if (clp[i - 1].dataz.dataa[2] != '.' || clp[i - 1].dataz.dataa[5] != '.' || strlen(clp[i - 1].dataz.dataa) != 10) {
            printf("Ошибка ввода\n");
            system("pause");
            return;
        }
        proverka[0] = clp[i - 1].dataz.dataa[0];
        proverka[1] = clp[i - 1].dataz.dataa[1];
        data[0] = atoi(proverka);
        for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
        proverka[0] = clp[i - 1].dataz.dataa[3];
        proverka[1] = clp[i - 1].dataz.dataa[4];
        data[1] = atoi(proverka);
        for (pro=0;pro<strlen(clp[structsize1].dataz.dataa);pro++){
        proverka[pro]=' ';
    }
        proverka[0] = clp[i - 1].dataz.dataa[6];
        proverka[1] = clp[i - 1].dataz.dataa[7];
        proverka[2] = clp[i - 1].dataz.dataa[8];
        proverka[3] = clp[i - 1].dataz.dataa[9];
        data[2] = atoi(proverka);
        if (data[0] > 31 || data[0] < 0 || data[1]>12 || data[1] < 0 || data[2]>2020 || data[2] < 2019) {
            printf("Ошибка ввода\n");
            system("pause");
            return;
        }
        break;
    case '5':
        printf("Введите адрес\n");
        fflush(stdin);
        gets(clp[i - 1].adres);
        gets(clp[i - 1].adres);
        break;
    case '0':
        return;
    default:
        system("cls");
        break;
    }
    return;
}

void deletee(void) {
    vivodProd();
    printf("Доступно для удаления %d\nУдалить поле №\n", structsize);
    scanf("%d", &j);
    if (j<1 || j>structsize) {
        printf("Такой структуры не существует\n");
        return;
    }
    for (i = j - 1; i < structsize; i++) {
        client[i] = client[i + 1];
        structsize--;
    }
    return;
}

void deleteeZak(void)
{
    vivodZakaz();
    printf("Доступно для удаления %d\nУдалить поле №\n", structsize1);
    scanf("%d", &j);
    if (j<1 || j>structsize1) {
        printf("Такой структуры не существует\n");
        return;
    }
    for (i = j - 1; i < structsize1; i++) {
        clp[i] = clp[i + 1];
        structsize1--;
    }
    return;

}

void vivodProd(void) {
    if (structsize == 0)
    {
        printf("Введите что нить\n");
    }
    else {

        puts("|   Тип Продукции   |     Количество    | Цена всей партии |  Цена за десяток  |   Дата изменения  |");
        puts("|___________________|___________________|__________________|___________________|___________________|");
        for (i = 0; i < structsize; i++)
        {

            printf("|%d)%17s|%19s|%14d BYN|%15d BYN|%19s|", i + 1, client[i].prod, client[i].kolv, client[i].sum, client[i].sum, client[i].data.dataa);
            printf("\n");
            puts("|___________________|___________________|__________________|___________________|___________________|");
        }
    }
    return;
}
void vivodtopProd(void) {
    if (structsize == 0)
    {
        printf("Введите что нить\n");
    }
    else {

        puts("|   Тип Продукции   |     Количество    | Цена всей партии |  Цена за десяток  |   Дата изменения  |");
        puts("|___________________|___________________|__________________|___________________|___________________|");
        for (i = 0; i < 3; i++)
        {

            printf("|%d)%17s|%19s|%14d BYN|%15d BYN|%19s|", i + 1, client[i].prod, client[i].kolv, client[i].sum, client[i].sum, client[i].data.dataa);
            printf("\n");
            puts("|___________________|___________________|__________________|___________________|___________________|");
        }
    }
    return;
}

void vivodtopZakaz(void) {
    if (structsize1 == 0)
    {
        printf("Введите что нить\n");
    }
    else {
        puts("___________________________________________________________________________________________________");
        puts("|   Тип Продукции   |     Количество    |    Общая цена    |     Дата заказа   |   Адрес доставки  |");
        puts("|___________________|___________________|__________________|___________________|___________________|");
        for (i = 0; i < 3; i++)
        {

            printf("|%d)%17s|%19s|%14d BYN|%19s|%19s|", i + 1, clp[i].prodz, clp[i].kolvz, clp[i].stom, clp[i].dataz.dataa, clp[i].adres);
            printf("\n");
            puts("|___________________|___________________|__________________|___________________|___________________|");
        }
    }
    return;
}
void vivodZakaz(void)
{
    if (structsize1 == 0)
    {
        printf("Введите что нить\n");
    }
    else {
        puts("___________________________________________________________________________________________________");
        puts("|   Тип Продукции   |     Количество    |    Общая цена    |     Дата заказа   |   Адрес доставки  |");
        puts("|___________________|___________________|__________________|___________________|___________________|");
        for (i = 0; i < structsize1; i++)
        {

            printf("|%d)%17s|%19s|%14d BYN|%19s|%19s|", i + 1, clp[i].prodz, clp[i].kolvz, clp[i].stom, clp[i].dataz.dataa, clp[i].adres);
            printf("\n");
            puts("|___________________|___________________|__________________|___________________|___________________|");
        }
    }
    return;
}

void menuvivod(void)
{
    while (1) {
        printf("1)Вывести продукцию\n2)Вывести заказы\n0)Выйти\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            SC
                vivodProd();
            SP
                system("cls");
            break;
        case '2':
            SC
                vivodZakaz();
            SP
                system("cls");
            break;
        case '0':
            return;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void menuPol(void)
{
    while (1) {
        printf("МЕНЮ ПОЛЬЗОВАТЕЛЯ\n1)Просмотреть продукцию\n2)Просмотреть заказы\n3)Просметреть топ продукции\n4)просмотреть топ заказов\n5)Отсортировать продукцию\n6)Найти\n7)Отсортировать заказы\n0)Выйти\n");
        scanf(" %c", &choice);
        switch (choice)
        {
        case '1':
            if (structsize < 1) {
                SC
                    printf("Администратор не в нёс данные либо список пуст\n");
                SP
                    SC
                    break;
            }
            SC
                vivodProd();

            SP
                SC
                break;
        case '2':
            if (structsize1 < 1) {
                SC
                    printf("Администратор не в нёс данные либо список пуст\n");
                SP
                    SC
                    break;
            }
            SC
                vivodZakaz();

            SP
                SC
                break;
        case '3':
            if (structsize < 1) {
                SC
                    printf("Администратор не в нёс данные либо список пуст\n");
                SP
                    SC
                    break;
            }
            SC
                vivodtopProd();

            SP
                SC
                break;
        case '4':
            if (structsize1 < 1) {
                SC
                    printf("Администратор не в нёс данные либо список пуст\n");
                SP
                    SC
                    break;
            }
            SC
                vivodtopZakaz();

            SP
                SC
                break;
        case '5':
            if (structsize < 1) {
                SC
                    printf("Администратор не в нёс данные либо список пуст\n");
                SP
                    SC
                    break;
            }
            SC
                sort();
            break;
        case '6':
            if (structsize < 1) {
                SC
                    printf("Администратор не в нёс данные либо список пуст\n");
                SP
                    SC
                    break;
            }
            SC
                search();
            SP
                SC
                break;
        case '7':
            if (structsize1 < 1) {
                SC
                    printf("Администратор не в нёс данные либо список пуст\n");
                SP
                    SC
                    break;
            }
            SC
                sortZak();
            SP
                SC
                break;
        case '0':
            zapis();
            zapisatPIP();
            zapisZak();
            SC
                menuexit();
            system("cls");
            break;
        default:
            system("cls");
            break;
        }
    }
    return;
}

void menuexit(void)
{
    while (1) {
        printf("Выйти в меню пользователей?\n1)Да\n2)Нет\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            SC
                menu();
            system("cls");
            break;
        case '2':
            return;
            break;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

void exitProg(void)
{
    while (1) {
        printf("Выйти из программы?\n1)Да\n2)Нет\n");
        scanf(" %c", &block);
        switch (block)
        {
        case '1':
            exit(0);
            SC
        case '2':
            SC
                menu();
            SC
                break;
        default:
            system("cls");
            break;
        }
    }
    system("cls");
}

int main(void) {
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    /*pipsize = 2;
    strcpy(pip[0].login, "sask");
    strcpy(pip[0].parol, "228");
    strcpy(pip[0].role, "admin");
    strcpy(pip[1].login, "asd");
    strcpy(pip[1].parol, "asd");
    strcpy(pip[1].role, "user");
    zapisatPIP();
    printf("Выход из программы\n");
    Sleep(1000);
    return 0;*/
    menu();
}