#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <chrono>
using namespace std;

#include "事件中枢_运存库_事件寄存.h"
#include "事件中枢_运存库_记忆.h"
#include "生理模型_运存库_内部调节关系.h"
#include "生理模型_运存库_外部调节数值.h"
#include "生理模型_运存库_生理数值.h"
#include "函数简化.h"

int 锁_运行正常 = 0;
int 锁_允许运行 = 0;

//同步时钟
int 自动调节运行刻 = 0;
int 运行刻 = 1000;
double 允许超时系数 = 0.3;
//每一步都会消耗1运行凭证,时钟线程会定时分发定时凭证
struct 结构体_运行凭证存储 {
    int 生理模型_计算线程 = 0;
    int 生理模型_生理事件判定线程 = 0;
    int 生理模型_生理稳态调节线程 = 0;
    int 事件中枢_事件寄存器 = 0;
}运行凭证;

void 线程定义_同步时钟() {
    mes("[PersonAI][同步时钟]开始启动", 1, 1);
    //加载资源写在这里下面
    std::chrono::time_point<std::chrono::steady_clock> 开始计时时间戳;
    std::chrono::time_point<std::chrono::steady_clock> 结束计时时间戳;
    double                                             本轮运行消耗时间;

    std::chrono::time_point<std::chrono::steady_clock> 超时开始计时时间戳;
    std::chrono::time_point<std::chrono::steady_clock> 超时结束计时时间戳;
    double                                             等待消耗时间;

    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][同步时钟]开始运行", 1, 1);
            开始计时时间戳 = std::chrono::steady_clock::now();//让第一次计时几乎为0，防止ER
            超时开始计时时间戳 = std::chrono::steady_clock::now();
            while (锁_允许运行 == 1) {
                超时结束计时时间戳 = std::chrono::steady_clock::now();
                等待消耗时间 = std::chrono::duration_cast<std::chrono::milliseconds>(超时结束计时时间戳 - 超时开始计时时间戳).count();
                //cout << "等待消耗时间:" << 等待消耗时间 << endl;
                if (等待消耗时间 > (运行刻 * 允许超时系数)) {
                    cout << (运行刻 * 允许超时系数) << "," << 等待消耗时间 << endl;
                    if (运行凭证.生理模型_计算线程 == 1) {
                        mes("[PersonAI][同步时钟][警告]'生理模型_计算线程'计算超时,超时了"         + to_string((等待消耗时间 - (运行刻 * 允许超时系数))) + "毫秒", 1, 1);}
                    if (运行凭证.生理模型_生理事件判定线程 == 1) {
                        mes("[PersonAI][同步时钟][警告]'生理模型_生理事件判定线程'计算超时,超时了" + to_string((等待消耗时间 - (运行刻 * 允许超时系数))) + "毫秒", 1, 1);}
                    if (运行凭证.生理模型_生理稳态调节线程 == 1) {
                        mes("[PersonAI][同步时钟][警告]'生理模型_生理稳态调节线程'计算超时,超时了" + to_string((等待消耗时间 - (运行刻 * 允许超时系数))) + "毫秒", 1, 1);}
                    if (运行凭证.事件中枢_事件寄存器 == 1) {
                        mes("[PersonAI][同步时钟][警告]'事件中枢_事件寄存器'计算超时,超时了"       + to_string((等待消耗时间 - (运行刻 * 允许超时系数))) + "毫秒", 1, 1);}
                }
                if (运行凭证.生理模型_计算线程 == 0 &&
                    运行凭证.生理模型_生理事件判定线程 == 0 &&
                    运行凭证.生理模型_生理稳态调节线程 == 0 &&
                    运行凭证.事件中枢_事件寄存器 == 0)
                {
                    结束计时时间戳 = std::chrono::steady_clock::now();
                    本轮运行消耗时间 = std::chrono::duration_cast<std::chrono::milliseconds>(结束计时时间戳 - 开始计时时间戳).count();
                    //cout << "本轮运行消耗时间:" << 本轮运行消耗时间 << endl;

                    运行凭证.生理模型_计算线程 = 1;
                    运行凭证.生理模型_生理事件判定线程 = 1;
                    运行凭证.生理模型_生理稳态调节线程 = 1;
                    运行凭证.事件中枢_事件寄存器 = 1;

                    开始计时时间戳 = std::chrono::steady_clock::now();
                    Sleep(运行刻);
                    超时开始计时时间戳 = std::chrono::steady_clock::now();
                }
            }
        }
    }
}
void 线程定义_事件中枢_事件判定与分发  () {
    mes("[PersonAI][事件中枢][事件判定与分发]开始启动", 1, 1);
    //加载资源写在这里下面

    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][事件中枢][事件判定与分发]开始运行", 1, 1);
            while (锁_允许运行 == 1) {
                //1、取出“事件中枢_列表_事件输入”里末尾的事件，并将其从“事件中枢_列表_事件输入”删除
                //2、判定取出的事件该去哪里，并把取出的事件发送到对应的列表里

            }

        }
    }
}
void 线程定义_事件中枢_事件寄存器      () {
    mes("[PersonAI][事件中枢][事件寄存器与时钟]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][事件中枢][事件寄存器与时钟]开始运行", 1, 1);

            while (锁_允许运行 == 1) {
                if (运行凭证.事件中枢_事件寄存器 == 1) {
                    运行凭证.事件中枢_事件寄存器 = 0;//消耗1运行凭证

                }
            }
        }
    }
}
void 线程定义_事件中枢_记忆系统        () {
    mes("[PersonAI][事件中枢][记忆系统]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][事件中枢][记忆系统]开始运行", 1, 1);
            while (锁_允许运行 == 1) {


            }
        }
    }
}
void 线程定义_生理模型_计算线程        () {
    mes("[PersonAI][生理模型][计算线程]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][生理模型][计算线程]开始运行", 1, 1);

            while (锁_允许运行 == 1) {
                if (运行凭证.生理模型_计算线程 == 1) {
                    //运行代码
                    
                    运行凭证.生理模型_计算线程 = 0;//消耗1运行凭证

                }
            }
        }
    }
}
void 线程定义_生理模型_生理事件判定线程() {
    mes("[PersonAI][生理模型][生理事件判定线程]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][生理模型][生理事件判定线程]开始运行", 1, 1);

            while (锁_允许运行 == 1) {
                if (运行凭证.生理模型_生理事件判定线程 == 1) {
                    //运行代码

                    运行凭证.生理模型_生理事件判定线程 = 0;//消耗1运行凭证

                }
            }
        }
    }
}
void 线程定义_生理模型_生理稳态调节线程() {
    mes("[PersonAI][生理模型][生理稳态调节线程]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][生理模型][生理稳态调节线程]开始运行", 1, 1);


            while (锁_允许运行 == 1) {
                if (运行凭证.生理模型_生理稳态调节线程 == 1) {
                    //运行代码

                    运行凭证.生理模型_生理稳态调节线程 = 0;//消耗1运行凭证
                }
            }
        }
    }
}
void 线程定义_中枢AI                   () {
    mes("[PersonAI][中枢AI]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][中枢AI]开始运行", 1, 1);
            while (锁_允许运行 == 1) {

            }
        }
    }
}
void 线程定义_执行器                   () {
    mes("[PersonAI][执行器]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][执行器]开始运行", 1, 1);
            while (锁_允许运行 == 1) {

            }
        }
    }
}
void 线程定义_交互面板                 () {
    mes("[PersonAI][交互面板]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        while (锁_允许运行 == 1) {
            mes("[PersonAI][交互面板]开始运行", 1, 1);
            while (锁_允许运行 == 1) {
                
            }
        }
    }
}
void 线程定义_总控线程                 () {
    mes("[PersonAI][总控线程]开始启动", 1, 1);
    //加载资源写在这里下面
    while (锁_运行正常 == 1) {
        mes("[PersonAI]开始运行", 1, 1);
        //线程同步开始运行
        锁_允许运行 = 1;
        while (锁_允许运行 == 1) {

        }
    }
}

//线程填入容器
std::thread 线程容器_同步时钟                 (&线程定义_同步时钟                 );
std::thread 线程容器_事件中枢_事件判定与分发  (&线程定义_事件中枢_事件判定与分发  );
std::thread 线程容器_事件中枢_事件寄存器      (&线程定义_事件中枢_事件寄存器      );
std::thread 线程容器_事件中枢_记忆系统        (&线程定义_事件中枢_记忆系统        );
std::thread 线程容器_生理模型_计算线程        (&线程定义_生理模型_计算线程        );
std::thread 线程容器_生理模型_生理事件判定线程(&线程定义_生理模型_生理事件判定线程);
std::thread 线程容器_生理模型_生理稳态调节线程(&线程定义_生理模型_生理稳态调节线程);
std::thread 线程容器_中枢AI                   (&线程定义_中枢AI                   );
std::thread 线程容器_执行器                   (&线程定义_执行器                   );
std::thread 线程容器_交互面板                 (&线程定义_交互面板                 );
std::thread 线程容器_总控线程                 (&线程定义_总控线程                 );

//启动程序
int main() {
    //初始设置
    //*CMD消息输出设置
    全局消息输出开关 = 1;

    //程序启动
    锁_运行正常 = 1;

    //将存储库中的数据写入变量库

    //线程加载
    线程容器_同步时钟                 .join();
    线程容器_事件中枢_事件判定与分发  .join();
    线程容器_事件中枢_事件判定与分发  .join();
    线程容器_事件中枢_事件寄存器      .join();
    线程容器_事件中枢_记忆系统        .join();
    线程容器_生理模型_计算线程        .join();
    线程容器_生理模型_生理事件判定线程.join();
    线程容器_生理模型_生理稳态调节线程.join();
    线程容器_中枢AI                   .join();
    线程容器_执行器                   .join();
    线程容器_交互面板                 .join();
    线程容器_总控线程                 .join();//"锁_允许运行"在这里被赋值为1，然后所有线程开始运行

    return 0;
}