#include <iostream>
#include <vector>
#include <string>
#include <unistd.h>
#include "task.hpp"
#include <sys/stat.h>
#include <sys/wait.h>
#include <cstdio>

#define PROCESSNUM 10
std::vector<task_t> tasks;

int main()
{
	//加載任務
	LoadTask(&tasks);
	//定義一個vector管理所有的管道，channel是描述，channels是組織
    std::vector<channel> channels;
    //初始化
    InitProcessPool(&channels);
    //開始進行
    StartProcessPool(channels);
    //清理
    CleanProcessPool(channels);
    return 0;
}

#pragma once

#include <iostream>
#include <vector>
//定義一個函數(shù)指針task_t指向返回值為void，沒有參數(shù)的函數(shù)
typedef void (*task_t)();

void task1()
{
    std::cout << "this is task1 running" << std::endl;
}
void task2()
{
    std::cout << "this is task2 running" << std::endl;
}
void task3()
{
    std::cout << "this is task3 running" << std::endl;
}
void task4()
{
    std::cout << "this is task4 running" << std::endl;
}
//加載任務函數(shù)，將任務pushback到vector中
void LoadTask(std::vector<task_t> *tasks)
{
    tasks->push_back(task1);
    tasks->push_back(task2);
    tasks->push_back(task3);
    tasks->push_back(task4);
}

class channel
{
public:
    // 描述父進程的fd，對應子進程的pid，子進程的名字
    channel(int cmdfd, int slaverid, const std::string &processname)
    :_cmdfd(cmdfd),_slaverid(slaverid),_processname(processname)
    {}

    int _cmdfd;
    pid_t _slaverid;
    std::string _processname;
};

void slaver()
{
    while(true)
    {
        // 用于存儲從標準輸入讀取的命令碼
        int cmdcode = 0;
        // 從標準輸入（管道）讀取數(shù)據(jù)，嘗試讀取sizeof(int)字節(jié)的數(shù)據(jù)到cmdcode中
        // 如果父進程不給子進程發(fā)送數(shù)據(jù)子進程就會進入阻塞等待
        int n = read(0, &cmdcode, sizeof(int));    
        if(n == sizeof(int))
        {
            // read的返回值與sizeof(int)相等，就輸出子進程pid和獲得命令碼
            // 如果命令碼有效就調用task任務，無效就退出
            std::cout <<"slaver say@ get a command: "<< getpid() << " : cmdcode: " 
            <<  cmdcode << std::endl;
            if(cmdcode >= 0 && cmdcode < tasks.size()) tasks[cmdcode]();
        }
        else break;
    }
}

void InitProcessPool(std::vector<channel>* channels)
{
    //用于存儲之前創(chuàng)建的管道的寫端文件描述符
    //目的是讓后續(xù)創(chuàng)建的子進程可以關閉這些舊的寫端文件描述符，避免資源泄漏
    std::vector<int> oldfds;
    //循環(huán)創(chuàng)建子進程
    for(int i = 0; i < PROCESSNUM; i++)
    {
        int pipefd[2] = {0};
        int n = pipe(pipefd);
        if(n < 0)
        {
            return;
        }

        pid_t id = fork();
        if(id < 0)
        {
            return;
        }
        if(id == 0)
        {
            //打印子進程pid，打印并關閉上一個管道寫端文件描述符
            std::cout << "child : " << getpid() << " close history fd: ";
            for(auto fd : oldfds)
            {
                std::cout << fd << " ";
                close(fd);
            }
            std::cout << std::endl;
            //關閉寫端通道
            close(pipefd[1]);
            //將當前管道的讀端文件描述符復制到標準輸入
            //這樣子進程就可以通過標準輸入從管道讀取數(shù)據(jù)
            dup2(pipefd[0],0);
            // 讀取完關閉管道讀端
            close(pipefd[0]);
            // 子進程主要業(yè)務
            slaver();
            //打印子進程要退出了
            std::cout << "process : " << getpid() << " quit" << std::endl;
            exit(0);
        }
        //父進程開始
        //關閉讀端
        close(pipefd[0]);
        //將當前channel信息添加到channels進行組織
        std::string name = "process-" + std::to_string(i);
        channels->push_back(channel(pipefd[1],id,name));
        //添加這個寫端的文件描述符，方便后面的進程關閉它
        oldfds.push_back(pipefd[1]);
        sleep(1);
    }
}

//打印一個選擇任務的菜單
void Menu()
{
    std::cout << "################################################" << std::endl;
    std::cout << "# 1. 任務一             2. 任務二               #" << std::endl;
    std::cout << "# 3. 任務三             4. 任務四               #" << std::endl;
    std::cout << "#                   0. 退出                     #" << std::endl;
    std::cout << "#################################################" << std::endl;
}

void StartProcessPool(std::vector<channel>* channels)
{
    while(true)
    {	
        int select = 0;
        Menu();
        sleep(1);
        //輸入選項
        std::cout << "Please Enter>> ";
        std::cin >> select;

        if(select <= 0 || select >= 5) break;
		//將控制碼也就是選擇的數(shù)字select1234轉化為0123，因為vector下標從0開始，所以要-1
        int cmdcode = select - 1;
		//通過管道寫入信息，等待slaver()讀取
        write(channels[select]._cmdfd, &cmdcode, sizeof(cmdcode));
        sleep(1);
    }
}

void CleanProcessPool(std::vector<channel> &channels)
{
    //每個channel對象的左邊為父進程的fd，右邊為子進程fd，斷開父進程fd，然后進程等待
    //父進程斷開后子進程會在管道中讀到0，即文件結束，然后子進程就會終止
    //然后被父進程回收
    for(const auto &c : channels){
        close(c._cmdfd);
        waitpid(c._slaverid, nullptr, 0);
    }
}