#include <iostream>
#include<fstream>
#include<cstdlib>
#include<vector>
#include<deque>
#include<queue>
#include<algorithm>
using namespace std;


struct process
{

    int id ;
    int cputime;
    int IOtime;
    int arrivaltime;
    int status; // 0 for ready and any other number for blocked
    int startarrivetime;
    int totaltime;
};
int cpu_clock=0;


bool sortbooling(process a,process b);
void debugger(deque<process> p,int num);
void Runningprocess(deque<process> p);
void Blockedprocess(deque<process> p);
void Readyprocess(deque<process> p);



int main()
{
    process temp_process;
    //vector<process>list_of_processes();
    deque<process>list_of_processes;
    deque<process>blockedqueue;
    deque<process>readyqueue;

    int numberofprocesses=0;

    int numberofblocked=0;
    int uselesscputime=0;
    int numberofready=0;

    char filename[50]= {"os.txt"};
    ifstream file;
    //cin.getline(filename,50);
    file.open(filename);

    if (!file.is_open())exit(EXIT_FAILURE);
    char word[50];
    // file>>word;
    while(file.good())
    {
        file>>word;
        temp_process.id=atoi(word);
        file>>word;
        temp_process.cputime=atoi(word);
        file>>word;
        temp_process.IOtime=atoi(word);
        file>>word;
        temp_process.arrivaltime=atoi(word);
        temp_process.status=0;
        temp_process.startarrivetime=temp_process.arrivaltime;
        temp_process.totaltime=temp_process.arrivaltime;

        list_of_processes.push_back(temp_process);

        cout <<temp_process.id <<" ";
        cout <<temp_process.cputime <<" ";
        cout <<temp_process.IOtime <<" ";
        cout <<temp_process.arrivaltime <<"a"<<endl;


        numberofprocesses++;
    }
    //cout << list_of_processes.at(1).arrivaltime<<endl;

    sort(list_of_processes.begin(),list_of_processes.end(),sortbooling);
    //cout << list_of_processes.size();
    //cout << list_of_processes.at(1).arrivaltime<<endl;

    cout<<"Processes"<<endl;
    debugger(list_of_processes, numberofprocesses);
//FCFS

    for(;;)
    {


        if (list_of_processes.empty()&&blockedqueue.empty())
        {
            //if()
            break;

        }

        cout<<cpu_clock<<":";
        if(list_of_processes.at(0).arrivaltime<=cpu_clock )
        {
            int j=1;
            while(3)
            {
                if(numberofprocesses==1)break;
                if(list_of_processes.at(j).arrivaltime<=cpu_clock)readyqueue.push_back(list_of_processes.at(j));
                else break;
                j++;
                numberofready++;

            }

            if (list_of_processes.at(0).status==0)
            {



//list_of_processes.at(0).totaltime=list_of_processes.at(0).cputime+cpu_clock
                for (int i=list_of_processes.at(0).cputime; i!=0; i--)
                {
                    Runningprocess(list_of_processes);
                    //blocked check
                    if(!readyqueue.empty())
                    {
                        for (int i=0; i<numberofready; i++)
                        {
                            Readyprocess(blockedqueue);



                        }
                    }


                    if(!blockedqueue.empty())
                    {
                        for (int i=0; i<numberofblocked; i++)
                        {
                            Blockedprocess(blockedqueue);
                            blockedqueue.at(i).status--;
                            if (blockedqueue.at(i).status==0)
                            {
                                blockedqueue.at(i).arrivaltime=cpu_clock;
                                blockedqueue.at(i).IOtime=0;
                                list_of_processes.push_back(blockedqueue.at(i));
                                blockedqueue.erase(blockedqueue.begin()+i);
                                numberofblocked--;
                                numberofprocesses++;

                            }
                        }
                    }
                    //
                    cpu_clock++;
                }

                if (list_of_processes.at(0).IOtime==0)
                {
                    numberofprocesses--;
                    list_of_processes.at(0).totaltime=cpu_clock;
                    list_of_processes.pop_front();


                }
                else
                {
                    list_of_processes.at(0).status=list_of_processes.at(0).IOtime;
                    list_of_processes.at(0).cputime=1;
                    blockedqueue.push_back(list_of_processes.at(0));
                    list_of_processes.pop_front();
                    numberofblocked++;
                    numberofprocesses--;




                }





                //ready to start

            }
        }
        else if(!blockedqueue.empty())
        {

            //it's a blocked process
            for (int i=0; i<numberofblocked; i++)
            {
                Blockedprocess(blockedqueue);
                blockedqueue.at(i).status--;
                if (blockedqueue.at(i).status==0)
                {
                    blockedqueue.at(i).arrivaltime=cpu_clock;
                    blockedqueue.at(i).IOtime=0;
                    list_of_processes.push_back(blockedqueue.at(i));
                    blockedqueue.erase(blockedqueue.begin()+i);
                    numberofblocked--;
                    numberofprocesses++;

                }
            }



            cpu_clock++;
            uselesscputime++;
        }












        else
        {


            //the processor is free and no processes to work
            uselesscputime++;
            cpu_clock++;
        }
        cout<<endl;
        sort(list_of_processes.begin(),list_of_processes.end(),sortbooling);
        //cout<<"Processes"<<endl;
        //debugger(list_of_processes, numberofprocesses);
        //cout<<"blocked"<<endl;
        //debugger(blockedqueue, numberofblocked);
        readyqueue.clear();
        numberofready=0;



    }




    return 0;
}



bool sortbooling(process a,process b)
{

    return ((a.arrivaltime<b.arrivaltime)||((a.arrivaltime==b.arrivaltime)&&(a.id<b.id)));

}

void debugger(deque<process> p,int num)
{
    for (int i=0; i<num; i++)
    {

        cout<<p.at(i).id<<endl;

    }

}


void Runningprocess(deque<process> p)
{

    cout<<"        i am running process";



}
void Readyprocess(deque<process> p)
{

    cout<<"       i am Ready process";



}


void Blockedprocess(deque<process> p)
{


    cout<<"         i am blocked process";






}