---

#include <iostream>
#include <fstream>
#include <iomanip>
#include <cstdlib>
#include <ctime>
#include <windows.h>
using namespace std;

int main() {
    // === НАСТРОЙКА ЛОКАЛИЗАЦИИ ===
    SetConsoleCP(1251);
    SetConsoleOutputCP(1251);
    setlocale(LC_ALL, "Russian");
    
    srand(time(0));
    
    // Емкости накопителей
    const int ln11 = 12;
    const int ln12 = 7;
    const int ln21 = 16;
    
    // Времена обработки в каналах
    const int lk11 = 12, lk12 = 16, lk13 = 7;
    const int lk21 = 12, lk22 = 11;
    const int lk31 = 13, lk32 = 9;
    
    const int max_time = 1000;
    
    // Каналы
    int k11[2000] = {0}, k12[2000] = {0}, k13[2000] = {0};
    int k21[2000] = {0}, k22[2000] = {0};
    int k31[2000] = {0}, k32[2000] = {0};
    
    // Накопители
    int n11[2000][ln11] = {0};
    int n12[2000][ln12] = {0};
    int n21[2000][ln21] = {0};
    
    // Входные, выходные, потерянные заявки
    int INz[2000][3] = {0};
    int OUTz[2000][2] = {0};
    int LOSTz[2000][8] = {0};
    
    int inz = 0, outz = 0, lostz = 0;
    
    // Время в накопителях
    int time_in_h11[10000] = {0};
    int time_in_h12[10000] = {0};
    int time_in_h21[10000] = {0};
    
    // === ОСНОВНОЙ ЦИКЛ МОДЕЛИРОВАНИЯ ===
    for (int t = 1; t <= max_time; t++) {
        // 1. Выход из системы (К31 и К32)
        if (k31[t-1] != k31[t] && k31[t-1] != 0) {
            outz++;
            OUTz[t][0] = k31[t-1];
        }
        if (k32[t-1] != k32[t] && k32[t-1] != 0) {
            outz++;
            OUTz[t][1] = k32[t-1];
        }
        
        // 2. Переход К21 и К22 -> К31/К32
        if (k21[t-1] != k21[t] && k21[t-1] != 0) {
            if (k31[t] == 0) {
                for (int i = t; i < t + lk31; i++) k31[i] = k21[t-1];
            } else if (k32[t] == 0) {
                for (int i = t; i < t + lk32; i++) k32[i] = k21[t-1];
            } else {
                lostz++;
                LOSTz[t][0] = k21[t-1];
            }
        }
        
        if (k22[t-1] != k22[t] && k22[t-1] != 0) {
            if (k31[t] == 0) {
                for (int i = t; i < t + lk31; i++) k31[i] = k22[t-1];
            } else if (k32[t] == 0) {
                for (int i = t; i < t + lk32; i++) k32[i] = k22[t-1];
            } else {
                lostz++;
                LOSTz[t][1] = k22[t-1];
            }
        }
        
        // 3. Переход из Н21 в К21 и К22
        if (k21[t] == 0 && n21[t][0] != 0) {
            for (int i = t; i < t + lk21; i++) k21[i] = n21[t][0];
            for (int i = 0; i < ln21-1; i++) n21[t][i] = n21[t][i+1];
            n21[t][ln21-1] = 0;
        }
        
        if (k22[t] == 0 && n21[t][0] != 0) {
            for (int i = t; i < t + lk22; i++) k22[i] = n21[t][0];
            for (int i = 0; i < ln21-1; i++) n21[t][i] = n21[t][i+1];
            n21[t][ln21-1] = 0;
        }
        
        // 4. Переход из 1-й фазы в Н21
        if (k11[t-1] != k11[t] && k11[t-1] != 0) {
            if (n21[t][ln21-1] != 0) {
                k11[t] = k11[t-1];
            } else {
                for (int i = 0; i < ln21; i++) {
                    if (n21[t][i] == 0) {
                        n21[t][i] = k11[t-1];
                        break;
                    }
                }
            }
        }
        
        if (k12[t-1] != k12[t] && k12[t-1] != 0) {
            if (n21[t][ln21-1] != 0) {
                lostz++;
                LOSTz[t][2] = k12[t-1];
            } else {
                for (int i = 0; i < ln21; i++) {
                    if (n21[t][i] == 0) {
                        n21[t][i] = k12[t-1];
                        break;
                    }
                }
            }
        }
        
        if (k13[t-1] != k13[t] && k13[t-1] != 0) {
            if (n21[t][ln21-1] != 0) {
                lostz++;
                LOSTz[t][3] = k13[t-1];
            } else {
                for (int i = 0; i < ln21; i++) {
                    if (n21[t][i] == 0) {
                        n21[t][i] = k13[t-1];
                        break;
                    }
                }
            }
        }
        
        // 5. Переход из накопителей в каналы 1-й фазы
        if (k11[t] == 0 && n11[t][0] != 0) {
            for (int i = t; i < t + lk11; i++) k11[i] = n11[t][0];
            for (int i = 0; i < ln11-1; i++) n11[t][i] = n11[t][i+1];
            n11[t][ln11-1] = 0;
        }
        
        if (k12[t] == 0 && n12[t][0] != 0) {
            for (int i = t; i < t + lk12; i++) k12[i] = n12[t][0];
            for (int i = 0; i < ln12-1; i++) n12[t][i] = n12[t][i+1];
            n12[t][ln12-1] = 0;
        }
        
        if (k13[t] == 0 && n12[t][0] != 0) {
            for (int i = t; i < t + lk13; i++) k13[i] = n12[t][0];
            for (int i = 0; i < ln12-1; i++) n12[t][i] = n12[t][i+1];
            n12[t][ln12-1] = 0;
        }
        
        // 6. Поступление новых заявок
        int ist1 = rand() % 10;
        int ist2 = rand() % 10;
        int ist3 = rand() % 10;
        
        if (ist1 == 1) {
            inz++;
            INz[t][0] = inz;
            if (n11[t][ln11-1] != 0) {
                lostz++;
                LOSTz[t][4] = INz[t][0];
            } else {
                for (int i = 0; i < ln11; i++) {
                    if (n11[t][i] == 0) {
                        n11[t][i] = INz[t][0];
                        break;
                    }
                }
            }
        }
        
        if (ist2 == 1) {
            inz++;
            INz[t][1] = inz;
            if (k12[t] != 0) {
                lostz++;
                LOSTz[t][5] = INz[t][1];
            } else {
                for (int i = t; i < t + lk12; i++) k12[i] = INz[t][1];
            }
        }
        
        if (ist3 == 1) {
            inz++;
            INz[t][2] = inz;
            if (n12[t][ln12-1] != 0) {
                lostz++;
                LOSTz[t][6] = INz[t][2];
            } else {
                for (int i = 0; i < ln12; i++) {
                    if (n12[t][i] == 0) {
                        n12[t][i] = INz[t][2];
                        break;
                    }
                }
            }
        }
        
        // 7. Копирование очередей на следующий такт
        for (int i = 0; i < ln11; i++) n11[t+1][i] = n11[t][i];
        for (int i = 0; i < ln12; i++) n12[t+1][i] = n12[t][i];
        for (int i = 0; i < ln21; i++) n21[t+1][i] = n21[t][i];
    }
    
    // === СБОР СТАТИСТИКИ ===
    int idle_time_k11=0, idle_time_k12=0, idle_time_k13=0;
    int idle_time_k21=0, idle_time_k22=0;
    int idle_time_k31=0, idle_time_k32=0;
    int idle_count_k11=0, idle_count_k12=0, idle_count_k13=0;
    int idle_count_k21=0, idle_count_k22=0;
    int idle_count_k31=0, idle_count_k32=0;
    
    for (int step = 1; step <= max_time; step++) {
        if (k11[step] == 0) { idle_time_k11++; if (step==1 || k11[step-1]!=0) idle_count_k11++; }
        if (k12[step] == 0) { idle_time_k12++; if (step==1 || k12[step-1]!=0) idle_count_k12++; }
        if (k13[step] == 0) { idle_time_k13++; if (step==1 || k13[step-1]!=0) idle_count_k13++; }
        if (k21[step] == 0) { idle_time_k21++; if (step==1 || k21[step-1]!=0) idle_count_k21++; }
        if (k22[step] == 0) { idle_time_k22++; if (step==1 || k22[step-1]!=0) idle_count_k22++; }
        if (k31[step] == 0) { idle_time_k31++; if (step==1 || k31[step-1]!=0) idle_count_k31++; }
        if (k32[step] == 0) { idle_time_k32++; if (step==1 || k32[step-1]!=0) idle_count_k32++; }
        
        for (int i = 0; i < ln11; i++) if (n11[step][i] != 0) time_in_h11[n11[step][i]]++;
        for (int i = 0; i < ln12; i++) if (n12[step][i] != 0) time_in_h12[n12[step][i]]++;
        for (int i = 0; i < ln21; i++) if (n21[step][i] != 0) time_in_h21[n21[step][i]]++;
    }
    
    double avg_idle_phase1 = (double)(idle_time_k11+idle_time_k12+idle_time_k13)/(idle_count_k11+idle_count_k12+idle_count_k13);
    double avg_idle_phase2 = (double)(idle_time_k21+idle_time_k22)/(idle_count_k21+idle_count_k22);
    double avg_idle_phase3 = (double)(idle_time_k31+idle_time_k32)/(idle_count_k31+idle_count_k32);
    
    double sum_h11=0, sum_h12=0, sum_h21=0;
    int count_h11=0, count_h12=0, count_h21=0;
    for (int id = 1; id <= inz; id++) {
        if (time_in_h11[id] > 0) { sum_h11 += time_in_h11[id]; count_h11++; }
        if (time_in_h12[id] > 0) { sum_h12 += time_in_h12[id]; count_h12++; }
        if (time_in_h21[id] > 0) { sum_h21 += time_in_h21[id]; count_h21++; }
    }
    
    // === ВЫВОД В КОНСОЛЬ ===
    cout << "================================================================" << endl;
    cout << "РЕЗУЛЬТАТЫ МОДЕЛИРОВАНИЯ (Детерминированный алгоритм. Вариант 12)" << endl;
    cout << "================================================================" << endl;
    cout << fixed << setprecision(2);
    cout << "1. Всего пришло заявок: " << inz << endl;
    cout << "2. Обработано заявок: " << outz << endl;
    cout << "3. Было утеряно заявок: " << lostz << endl;
    cout << "   (Осталось в системе: " << (inz - outz - lostz) << ")" << endl;
    cout << "4. Среднее время простоя каналов:" << endl;
    cout << "   - Фаза 1 (К11,К12,К13): " << avg_idle_phase1 << " тактов" << endl;
    cout << "   - Фаза 2 (К21,К22): " << avg_idle_phase2 << " тактов" << endl;
    cout << "   - Фаза 3 (К31,К32): " << avg_idle_phase3 << " тактов" << endl;
    cout << "5. Среднее время в накопителях:" << endl;
    cout << "   - Н11: " << (count_h11?sum_h11/count_h11:0) << " тактов" << endl;
    cout << "   - Н12: " << (count_h12?sum_h12/count_h12:0) << " тактов" << endl;
    cout << "   - Н21: " << (count_h21?sum_h21/count_h21:0) << " тактов" << endl;
    
    // === ЗАПИСЬ В ФАЙЛ (ТОЧНО КАК В АСИНХРОННОМ СПОРАДИЧЕСКОМ АЛГОРИТМЕ) ===
    ofstream myfile("determ.txt");
    myfile << "\xEF\xBB\xBF";  // BOM для UTF-8
    
    for (int t_idx = 1; t_idx <= max_time; t_idx++) {
        // Входные заявки от источников
        myfile << INz[t_idx][0] << "\t" << INz[t_idx][1] << "\t" << INz[t_idx][2] << "\t";
        
        // Накопитель Н11 (через запятую)
        for (int i = 0; i < ln11; i++) myfile << n11[t_idx][i] << ",";
        myfile << "\t";
        
        // Канал К11
        myfile << k11[t_idx] << "\t";
        
        // Накопитель Н12 (через запятую)
        for (int i = 0; i < ln12; i++) myfile << n12[t_idx][i] << ",";
        myfile << "\t";
        
        // Каналы К12, К13
        myfile << k12[t_idx] << "\t" << k13[t_idx] << "\t";
        
        // Накопитель Н21 (через запятую)
        for (int i = 0; i < ln21; i++) myfile << n21[t_idx][i] << ",";
        myfile << "\t";
        
        // Каналы К21, К22
        myfile << k21[t_idx] << "\t" << k22[t_idx] << "\t";
        
        // Каналы К31, К32
        myfile << k31[t_idx] << "\t" << k32[t_idx] << "\t";
        
        // ВЫХОДНЫЕ ЗАЯВКИ (в одной ячейке через запятую)
        myfile << OUTz[t_idx][0] << "," << OUTz[t_idx][1] << "\t";
        
        // ПОТЕРЯННЫЕ ЗАЯВКИ (в одной ячейке через запятую) - ВСЕ 8 элементов
        for (int i = 0; i < 8; i++) {
            myfile << LOSTz[t_idx][i];
            if (i < 7) myfile << ",";
        }
        
        myfile << endl;
    }
    myfile.close();
    
    cout << "\nРезультаты сохранены в файл determ.txt" << endl;
    system("pause");
    
    return 0;
}