#include<iostream>
#include<thread>
#include<chrono>


using namespace std;

/*
    I hope maintindihan mo tong explanation ko :)
    SO ang clog at cerr ay kadalasang ginagamit sa pagdedebug ng code,
    para makita ang mali sa iyong code ganun pero magkaiba silang dalawa,
    si cerr ay un-buffered pero si clog ay buffered. Bago ko muna ituloy,
    ano nga ba ang buffer sa c++ at iba pang programming language?

    Sa bawat program na pinoproduce natin ay merong nakalaan na storage
    sa certain memory ng ating RAM, kuwari may code kang gento:
    char sample[6] = "ABCDEF";
                ^ insert natin ang number na to na tumutukoy sa kung gaano
                  karami ang kakailanganing 'blocks'(space) na magagamit
                  sa memory para magstore ng string.

        BEFORE          AFTER
     1111  - 'x'     1111  - 'x'
    [1112] - 't'    [1112] - 'A'
    [1113] - 'u'    [1113] - 'B'
    [1114] - 'p'    [1114] - 'C'
    [1115] - 'w'    [1115] - 'D'
    [1116] - 'f'    [1116] - 'E'
    [1117] - 'p'    [1117] - 'F'
     1118  - 'u'     1118  - 'u'

    Eto ang tinatawag nating buffer kung saan dinadala muna ni computer ang data
    sa RAM bago ilagay sa mismong storage ng computer. Bat nga ba to ginagawa ni computer?
    Kasi mas mabilis magprocess ang RAM kesa sa typical na storage like HDD at SSD,
    pansin naman natin kung gano kamahal ang RAM kesa sa SSD, (8gb RAM kasing price lang ng 256gb SSD)
    Hindi agad agad makikita ang output kapag nasa buffer pa sya.
    Try mo tong i run: ang lalabas na resulta ay sabay sila na magaappear ang 1 2 3 4 5.
*/
void buffered(){
    int i = 0;
    while(i < 5){
        cout << i + 1 << " ";
        this_thread::sleep_for(chrono::seconds(1)); //sleeps the thread (tigil muna si code)
        i++;
    }
    cout << endl;
}
/*
    Eto namang code na susunod ay deretso na sa mismong output ni computer, hindi na sya tutungo pa
    sa RAM. Try mo irun : ang lalabas ay isa isa na lalabas si 1 2 3 4 5.
*/
void unbuffered(){
    int i = 0;
    while(i < 5){
        cout << i + 1 << " " << flush;
        this_thread::sleep_for(chrono::seconds(1)); //sleeps the thread (tigil muna si code)
        i++;
    }
    cout << endl;
}
/*
    so ano nga bang relation nito sa cerr at clog?
    Gaya ng nasabi ko si cerr ay un-buffered at si clog ay buffered.
    Si cerr kapag ginamit na natin immediately lalabas na agad ang output natin,
    whereas si clog, di pa muna lalabas, unles gumamit tayo ng (flush)[ginagawang unbuffered na sya]
    or natapos na si program.

*/
/*
    kapag gumamit tayo ng cout at ni redirect natin ang output sa *.txt file,
    dederetso sa mismong file ang mga output natin imbis sa console. Pero ano kayang mangyayari,
    kapag nagkaroon ng error, pero usto nating malamn na may error. Lalabas ang error pero mapupunta sya sa
    *.txt file. Dito na aaksyon si cerr, ginagamit sya para makita natin ang error sa console, hindi
    dederetso sa *.txt file ang output, bagkus dederetso sya sa console.*/
/*
    Pero ewan, base sa conteksto na nakasaad sa google at sa mismong c++ na documentation, na ang isa ay buffered
    at ang isa ay unbuffered. pero kung gagayahin natin ang codes na nakalagay sa taas at pinaltan ang
    cout ng cerr at clog, hindi naman magiistay sa buffer si clog. Hindi sya titigil parehas lang sila ni cerr.
    Pero siguro may pagkakaiba sila at makikita natin kung buffered or unbuffered ba talaga si clog
    Napakakipot ng pinagkaiba nila pero malinaw ang gamit nila, ginagamit sila sa pag dedebugging para malaman
    bugs, tsaka hindi dederetso sa file ng output ang *txt ang ipiprint mo. Ayon ang pinagkaparehas nila.
    Cerr = error stream
    clog = logging stream

    isa pang point pala, siguro kapag ginagamit si cerr para immediately malaman ang error
    samantalang kay clog, tuloy tuloy na ilalagay sa isang file lahat ng mga errors, then tsaka makikita lahat ng
    logs, kumbaga si clog ay general tas cerr ay specific lang

*/

void cerrSample(){
    char str[] = "Unable to read...";
    cerr << "Error message: " << str << endl;
}

void clogSample(){
    char str[] = "Unable to read...";
    clog << "Error message: " << str << endl;
}


int main(){
    unbuffered();
}