3rd version

#include <iostream>
#include <bits/stdc++.h>
using namespace std;
string fillTheSpace(int value,string space,int length)
{
    string stringWithSpaces= to_string(value);
    while(stringWithSpaces.length()<length)
    {
        string spaceChar = space;
        stringWithSpaces=spaceChar.append(stringWithSpaces);
    }
    return stringWithSpaces;
}
int headerEmp(){
    ifstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::in);
    string hEmp = "";
    char hE;
    for (int i = 0; i < 4; ++i) {
        sequenceSet>>hE;
        hEmp+=hE;
    }
    if (hEmp=="00-1"){
        return -1;
    }
    int firstEmpRecord = stoi(hEmp);
    return firstEmpRecord;
}
int headerNonEmpty(){
    ifstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::in);
    sequenceSet.seekg(4);
    string hEmp = "";
    char hE;
    for (int i = 0; i < 4; ++i) {
        sequenceSet>>hE;
        hEmp+=hE;
    }
    if (hEmp=="00-1"){
        return -1;
    }
    int firstEmpRecord = stoi(hEmp);
    return firstEmpRecord;
}
struct Record{
    int key;
    int value;
};
void createBlocks(int numOfBlocks, int numOfRecords){
    ofstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::out);
    int maxVal = 0000;
    int numOfBlock = 2;
    string full = "";
    sequenceSet << setfill ('0') <<setw (4);
    sequenceSet << 1 ;
    sequenceSet << setfill ('0') <<setw (4);
    sequenceSet << -1 ;
    for (int i = 0; i < numOfRecords*8 ; ++i) {
        full+="@";
    }
    for(int i=0 ; i < numOfBlocks-1 ; i++){
        sequenceSet << setfill ('0') <<setw (4);
        sequenceSet << numOfBlock ;
        numOfBlock++;
        sequenceSet << setfill ('0') <<setw (4);
        sequenceSet << maxVal ;
        sequenceSet<<full;
    }

    sequenceSet << setfill ('0') <<setw (4);
    sequenceSet << -1 ;
    sequenceSet << setfill ('0') <<setw (4);
    sequenceSet << maxVal ;
    sequenceSet<<full;
}
int getNext(int recordNo, int numOfRecords)
{
    ifstream sequenceSet;
    sequenceSet.open("sequenceSet.txt", ios::in);
    int z =(8 + (recordNo - 1) * (numOfRecords+1) * 8);
    sequenceSet.seekg(8 + (recordNo - 1) * (numOfRecords+1) * 8);
    char x ;
    string y;
    for (int i = 0; i < 4; ++i) {
        sequenceSet >> x;
         y +=x;
    }
    sequenceSet.close();
    if(y=="00-1")
        return -1;
    return stoi(y);
    int c;
}
void setNext(int recordNo,int next, int numOfRecords)
{
    fstream sequenceSet;
    sequenceSet.open("sequenceSet.txt", ios::in|ios::out);
    sequenceSet.seekg(8 + (recordNo - 1) * (numOfRecords+1) * 8);

        sequenceSet << fillTheSpace(next,"0",4);

    sequenceSet.close();

}
int getMax(int recordNo, int numOfRecords)
{
    ifstream sequenceSet;
    sequenceSet.open("sequenceSet.txt", ios::in);
    int pos=12 + (recordNo - 1) * (numOfRecords+1) * 8;
    sequenceSet.seekg(pos);
    char x ;
    string y="";
    for (int i = 0; i < 4; ++i) {
        sequenceSet >> x;
        y+=x;
    }
    sequenceSet.close();
    if(y=="00-1")
        return -1;
    return stoi(y);
}
int turnRRnToByte(int rrn,int numOfRecords){
    int x=(8 + (rrn-1)*8*(numOfRecords+1));
    return x ;
}
int searchBlock(int key, int numOfRecords){
    //insertion search
    //return RRn of block that val in.
    //search by key
    int rrnOfBlock;//RRn
    ifstream sequenceSet;
    sequenceSet.open("sequenceSet.txt", ios::in);
    int curBlock,maxVal,nextBlock;
    curBlock= headerNonEmpty();
    while(true){
        maxVal= getMax(curBlock,numOfRecords);
        nextBlock= getNext(curBlock,numOfRecords);
        if (key < maxVal || nextBlock == -1){
            return curBlock;
        }
        curBlock=nextBlock;
    }
}
string loadBlock(int posOfBegBlock, int numOfRecords){
    string block="";
    ifstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::in);
    sequenceSet.seekg(posOfBegBlock);
    char pt;
    for (int i = 0; i < (numOfRecords+1)*8; ++i) {
        sequenceSet>>pt;
        block+=pt;
    }
    return block;
}//take block from file to string
void returnBlock(string newBlock,int posOfBegBlock){
    fstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::out|ios::in);
    sequenceSet.seekp(posOfBegBlock);
    sequenceSet<<newBlock;
}//return new block to file
string sortBlock(string unSortedBlock){
    int numEmptySpaces=0;
    string block="";
    for (int i = 0; i < unSortedBlock.length(); ++i) {
        if (unSortedBlock[i]!='@'){
            block+=unSortedBlock[i];
        }
        else
        {
            numEmptySpaces++;
        }
    }
    vector<pair<int,int>>rec;
    string ke="";
    string va="";
    int kk;
    int vv;

    for (int i = 8; i < block.length()-4; ++i) {
        ke+=block[i];
        va+=block[i + 4];
        if ( i%4 == 3 && i!=0){
            i+=4;
            kk = stoi(ke);
            vv = stoi(va);
            rec.push_back({kk,vv});
            ke="";
            va="";
        }
    }
    sort(rec.begin(), rec.end());
    int maxK=rec[rec.size() - 1].first;
    string sortedBlock="";
    for (int i = 0; i < 4; ++i) {
        sortedBlock+=block[i];
    }
    string maxValue= to_string(maxK);
    while(maxValue.length()<4)
    {
        string zero="0";
        maxValue=zero.append(maxValue);
    }
    sortedBlock+=maxValue;
    for (int i = 0; i < rec.size(); ++i) {
        string keyy= to_string(rec[i].first);
        while(keyy.length()<4)
        {
            string zero="0";
            keyy=zero.append(keyy);
        }
        string value= to_string(rec[i].second);
        sortedBlock+=keyy;
        while(value.length()<4)
        {
            string zero="0";
            value=zero.append(value);
        }
        sortedBlock+=value;
        //cout<<rec[i].first<<" "<<rec[i].second<<"\n";
    }
    for (int i = 0; i < numEmptySpaces; ++i) {
        sortedBlock.append("@");
    }
    return sortedBlock;
}
void insert(string block,int key, int val,int blockNum,int numOfRecords){
    //val*4 key*4
    //4"@@@@key"4"val"
    string value= to_string(val);
    while(value.length()<4)
    {
        string zero="0";
        value=zero.append(value);
    }
    string curKey= to_string(key);
    while(curKey.length()<4)
    {
        string zero="0";
        curKey=zero.append(curKey);
    }
    for (int i = 0; i < block.length(); ++i) {
        if (block[i]=='@'){
            for (int j = 0; j < 4; ++j) {
                block[j+i]=curKey[j];
            }
            i+=4;
            for (int j = 0; j < 4; ++j) {
                block[j+i]=value[j];
            }
            break;
        }
    }
    returnBlock(sortBlock(block), turnRRnToByte(blockNum, numOfRecords));
}

void splitBlock(int blockNum,string block,int numOfRecords){
    block = sortBlock(block);
    int firstEmptyBlock=headerEmp();
    int secondEmptyBlock= getNext(firstEmptyBlock,numOfRecords);
    string firstBlock="00000000";
    string secondBlock="00000000";
    for (int i = 8; i < block.length(); ++i) {
        if(i<(numOfRecords)*8)
        {
            firstBlock+=block[i];
        }
        else
        {
            secondBlock+=block[i];
        }
    }
    while(firstBlock.length()<8*(numOfRecords+1))
    {

        firstBlock.append("@");
    }
    while(secondBlock.length()<8*(numOfRecords+1))
    {
        secondBlock.append("@");
    }
    firstBlock=sortBlock(firstBlock);
    secondBlock= sortBlock(secondBlock);
    int next1=getNext(blockNum,numOfRecords);

    returnBlock(firstBlock, turnRRnToByte(blockNum,numOfRecords));
    returnBlock(secondBlock, turnRRnToByte(firstEmptyBlock,numOfRecords));
    fstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::out|ios::in);
    sequenceSet<<fillTheSpace(secondEmptyBlock,"0",4);
    setNext(firstEmptyBlock,next1 ,numOfRecords);
    setNext(blockNum,firstEmptyBlock,numOfRecords);

}
void insertRecord(int key,int value,int numOfRecords){
    //search rrn of block
    //load rnn
    //insert
    //sortBlock
    //return
    // next block Done if split
    //
    int blockNum;//rrn
    fstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::out|ios::in);
    if (headerNonEmpty() == -1){
        blockNum=1;
        sequenceSet<<"0002";
        sequenceSet<<"0001";
        sequenceSet<<"00-1";
    }
    else{
        blockNum= searchBlock(key, numOfRecords);
    }
    int blockByteOff;
    blockByteOff = turnRRnToByte(blockNum,numOfRecords);
    string block = loadBlock(blockByteOff,numOfRecords);
    if (block[block.length()-1]!='@'){
        //overflow
        block.append(fillTheSpace(key,"0",4));
        block.append(fillTheSpace(value,"0",4));
         splitBlock(blockNum,block,numOfRecords);
    }
    else{
        insert(block,key,value,blockNum, numOfRecords);
    }
}


/*
 void deleteKey(int  key, int numOfRecords){
    int currentBlock;
    currentBlock =searchBlock( key, numOfRecords);
    fstream sequenceSet;
    sequenceSet.open("sequenceSet.txt",ios::out|ios::in);
    sequenceSet.seekp(turnRRnToByte(currentBlock, numOfRecords),ios::beg);
    sequenceSet.seekp(key,ios::cur);
    char f[4];

    sequenceSet.read(f,4);
    if(f=="****"){
        cout<<" Ivalue Already deleted.."<<endl;
    }else{
        long long pos=sequenceSet.tellp();
        sequenceSet.seekp(pos+4);


        sequenceSet.write("****",4);
        cout<<"Deleted Successfully.."<<endl;
    }
    sequenceSet.close();
}
*/
int main() {
    createBlocks(3,2);
    insertRecord(1111,2222,2);
    insertRecord(3333,4444,2);
    insertRecord(5555,6666,2);
    //cout<<loadRecord(9,2);
    //returnBlock("#0010001@@@1@@@5@@@@@@@@",9);
    //addRecord(3333,5555);
    //cout<<headerEmp()<<" "<<headerNonEmpty();
    //cout<<searchBlock(2,2,2);
    //cout<< getNext(2,2)<<" " << getMax(2,2);
    //cout<<searchBlock(3,2);
    //sortBlock("0001000600010006000300080004000900020007");
    //sortBlock("77778888111122225555666633334444@@@@@@@@");
  //  insertRecord(3,7,2);
    return 0;
}
// close file in all functions