#include "filesys.h"
#include <string>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

FileHandle::FileHandle(int pos, MyChunk* chunk) {
this->pos = pos;
this->size = 0;
this->offset = 0;
// each file handle point to a chuk of data
this->chunk = chunk;
}

MyChunk::MyChunk(int size, int start,
   MyChunk* nextChunk, MyChunk* prevChunk, bool empty) {
this->nextChunk = nextChunk;
this->prevChunk = prevChunk;
this->size = size;
this->start = start;
this->empty = empty;
// each chunk contain 2 parts
// head of the chunk and data of the chunk
this->data_start = start + CHUNK_HEAD_SIZE;
this->nextChunkInFile = 0;
}

MyEntry::MyEntry(MyChunk* data, MyEntry* nextEntry, MyEntry* prevEntry) {
this->data = data;
this->nextEntry = nextEntry;
this->prevEntry = prevEntry;
}

bool Filesystem::containName(const string str) {

MyEntry * entry = findEntry(str);

if (entry == 0) {
   return false;
}
return true;
}

void Filesystem::writeChunkHeader2Disk(MyChunk* chunk) {

// write first 4 integers of the chunk to file
this->write_int(chunk->start + INDEX_CHUNK_SIZE, chunk->size);
this->write_int(chunk->start + INDEX_CHUNK_EMPTY, chunk->empty);
if (chunk->nextChunk == 0) {
   this->write_int(chunk->start + INDEX_CHUNK_NEXT_INDEX,
            NO_NEXT_CHUNK_INDEX);
} else {
   this->write_int(chunk->start + INDEX_CHUNK_NEXT_INDEX,
            chunk->nextChunk->start);
}
if (chunk->nextChunkInFile == 0) {
   this->write_int(chunk->start + INDEX_CHUNK_NEXT_DATA_IN_FILE_INDEX,
            NO_NEXT_CHUNK_INDEX);
} else {
   this->write_int(chunk->start + INDEX_CHUNK_NEXT_DATA_IN_FILE_INDEX,
            chunk->nextChunkInFile->start);
}

}

void Filesystem::addEntry(MyEntry* entry) {
if (this->entries == 0) {
   this->entries = entry;
} else {
// move to the end of list
   MyEntry * curr = this->entries;
   while (curr->nextEntry != 0) {
         curr = curr->nextEntry;
   }
   // add it and write it to disk
   curr->nextEntry = entry;
   // cout << entry->data->start << "\n";
   this->write_int(curr->data->start + INDEX_CHUNK_NEXT_ENTRY_INDEX,
            entry->data->start);
   entry->prevEntry = curr;
   this->write_int(entry->data->start + INDEX_CHUNK_NEXT_ENTRY_INDEX,
            NO_NEXT_CHUNK_INDEX);
   this->write_int(entry->data->start + INDEX_CHUNK_EMPTY,
            false);
}
}

MyEntry* Filesystem::findEntry(const string str) {
MyEntry * entry = this->entries;
MyChunk * chunk;
string a_str;
// iterate over the list
while (entry != 0) {
   chunk = entry->data;
   if (chunk->empty == false) {
   // read name of the entry
         this->read_string(chunk->data_start, a_str, ENTRY_STRING_SIZE);
         // get the expected string length
         a_str = a_str.substr(0, str.length());
         // compare them
         if (a_str == str) {
            return entry;
         }
   }
   entry = entry->nextEntry;
}
return 0;
}

void Filesystem::format() {
// set up the chunks of files
this->chunks = new MyChunk(this->m_disk_size, 0, 0, 0, true);
writeChunkHeader2Disk(this->chunks);

// set up list of entries
this->entries = 0;
// create entry chunk of this directory
create(".");
}

void Filesystem::initialize() {

// set up list do data chunk
createChunkList();
// set up list of entries
createEntryList();
// coneect entry to data chunk
updateFIleChunkInEntryList();

}

void Filesystem::updateFIleChunkInEntryList() {
MyEntry * entry = this->entries;

while (entry != 0) {
// update chunk list of each entry
   this->updateFIleChunkOfEntry(entry);
   entry = entry->nextEntry;
}
}

void Filesystem::updateFIleChunkOfEntry(MyEntry* entry) {

// read index of next chunk in this file
int next;
this->read_int(entry->data->start + INDEX_CHUNK_NEXT_DATA_IN_FILE_INDEX,
         next);
string str;
this->read_string(entry->data->data_start, str, ENTRY_STRING_SIZE);

// try to connect to the current chunk
// and read the next chunk until the ned of this file on disk
MyChunk * curr = entry->data;
MyChunk * prev;
while (next != NO_NEXT_CHUNK_INDEX) {
   prev = curr;
   curr = getChunkByStartAddress(next);
   prev->nextChunkInFile = curr;
   this->read_int(next + INDEX_CHUNK_NEXT_DATA_IN_FILE_INDEX,
            next);

}
}

void Filesystem::createEntryList() {
// set up the first enties of list which entry "."
this->entries = new MyEntry(this->chunks, 0, 0);
MyEntry * curr = this->entries;
int next;
this->read_int(curr->data->start + INDEX_CHUNK_NEXT_ENTRY_INDEX, next);
MyEntry * prev = 0;

// connect other entties to list
while (next != NO_NEXT_CHUNK_INDEX) {

   string str;
   this->read_string(next + CHUNK_HEAD_SIZE, str, ENTRY_STRING_SIZE);

   prev = curr;
   curr = new MyEntry(getChunkByStartAddress(next), 0, prev);
   this->read_int(curr->data->start + INDEX_CHUNK_NEXT_ENTRY_INDEX, next);
   // cout << curr->data->start << "\n";
   prev->nextEntry = curr;
}

}

MyChunk* Filesystem::getChunkByStartAddress(int start) {
// iterate over list of chunk to the righ chunk at index start
MyChunk * chunk = this->chunks;
while (chunk != 0) {
   if (chunk->start == start) {
         return chunk;
   }
   chunk = chunk->nextChunk;
}
return 0;
}

1. Conversion (a) Convert the binary number 00100101 to decimal....