/// This function reads data from file
void readFile( std::string t_filepath )
{
    std::ifstream a_csvread( t_filepath.c_str() );
    if(!a_csvread.is_open())
        std::cout << "Error at opening file: " << t_filepath << std::endl;
    else {
        // file is available

        // read file header
        HeaderData a_header;
        readHeader( a_csvread, a_header );
        std::cout <<  a_header.m_versionString << ": " << a_header.m_major << "." << a_header.m_minor << std::endl;
        std::cout <<  a_header.m_numberOfDataString << ": " << a_header.m_numberOfDataItems << std::endl;

        // read file data
        for( CenterPoint a_data; readData( a_csvread, a_data ); ) { // Nice for-loop
            std::cout <<  a_data.m_name << ", x=" << a_data.m_x << ", y=" << a_data.m_y << std::endl;
        }

        a_csvread.close();
    }
}

bool Foam::IOobject::headerOk()
{
    bool ok = true;

    Istream* isPtr = objectStream();

    // If the stream has failed return
    if (!isPtr)
    {
        if (objectRegistry::debug)
        {
            Info
                << "IOobject::headerOk() : "
                << "file " << objectPath() << " could not be opened"
                << endl;
        }

        ok = false;
    }
    else
    {
        // Try reading header
        if (!readHeader(*isPtr))
        {
            if (objectRegistry::debug)
            {
                IOWarningIn("IOobject::headerOk()", (*isPtr))
                    << "failed to read header of file " << objectPath()
                    << endl;
            }

            ok = false;
        }
    }

    delete isPtr;

    return ok;
}

bool BasePersistenceManager::initLoad(const Common::String &filename) {
	if (DID_FAIL(readHeader(filename))) {
		cleanup();
		return STATUS_FAILED;
	}
	_saving = false;

	if (_savedName == "" || scumm_stricmp(_savedName.c_str(), _gameRef->getName()) != 0) {
		debugC(kWintermuteDebugSaveGame, "ERROR: Saved game name doesn't match current game");
		cleanup();
		return STATUS_FAILED;
	}

	// if save is newer version than we are, fail
	if (_savedVerMajor >  DCGF_VER_MAJOR ||
	        (_savedVerMajor == DCGF_VER_MAJOR && _savedVerMinor >  DCGF_VER_MINOR) ||
	        (_savedVerMajor == DCGF_VER_MAJOR && _savedVerMinor == DCGF_VER_MINOR && _savedVerBuild > DCGF_VER_BUILD)
	   ) {

		debugC(kWintermuteDebugSaveGame, "ERROR: Saved game version is newer than current game");
		debugC(kWintermuteDebugSaveGame, "ERROR: Expected %d.%d.%d got %d.%d.%d", DCGF_VER_MAJOR, DCGF_VER_MINOR, DCGF_VER_BUILD, _savedVerMajor, _savedVerMinor, _savedVerBuild);
		cleanup();
		return STATUS_FAILED;
	}

	// if save is older than the minimal version we support
	if (_savedVerMajor <  SAVEGAME_VER_MAJOR ||
	        (_savedVerMajor == SAVEGAME_VER_MAJOR && _savedVerMinor <  SAVEGAME_VER_MINOR) ||
	        (_savedVerMajor == SAVEGAME_VER_MAJOR && _savedVerMinor == SAVEGAME_VER_MINOR && _savedVerBuild < SAVEGAME_VER_BUILD)
	   ) {
		debugC(kWintermuteDebugSaveGame, "ERROR: Saved game is too old and cannot be used by this version of game engine");
		debugC(kWintermuteDebugSaveGame, "ERROR: Expected %d.%d.%d got %d.%d.%d", DCGF_VER_MAJOR, DCGF_VER_MINOR, DCGF_VER_BUILD, _savedVerMajor, _savedVerMinor, _savedVerBuild);
		cleanup();
		return STATUS_FAILED;

	}

	return STATUS_OK;
}

FfhReader::FfhReader(const std::string& filename) : 
   HistogramReader(filename)
{
   readHeader();

   auto it = images.find("IntensityNormalisation");
   if (it != images.end())
   {
      intensity_normalisation = it->second;
      auto size = intensity_normalisation.size();
      std::vector<int> dims = { 1, size.height, size.width };
      intensity_normalisation = intensity_normalisation.reshape(0, 3, &dims[0]);

      // For old-style uncorrected (for #frames) normalisation maps, correct based on maximum
      if (intensity_normalisation.type() == CV_16U)
      {
         double mn, mx;
         cv::minMaxIdx(intensity_normalisation, &mn, &mx);
         intensity_normalisation.convertTo(intensity_normalisation, CV_32F, 1.0 / mx, 0);
      }
   }
}

SaveStateList SaveFileManager::list(const Common::String &target) {
	Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
	Common::StringArray files = saveFileMan->listSavefiles(target + ".###");

	SaveStateList saveList;
	for (Common::StringArray::const_iterator fileName = files.begin(); fileName != files.end(); ++fileName) {
		Common::InSaveFile *saveFile = saveFileMan->openForLoading(*fileName);
		if (saveFile == nullptr || saveFile->err()) {
			continue;
		}

		BladeRunner::SaveFileHeader header;
		readHeader(*saveFile, header);

		int slotNum = atoi(fileName->c_str() + fileName->size() - 3);
		saveList.push_back(SaveStateDescriptor(slotNum, header._name));
	}

	Common::sort(saveList.begin(), saveList.end(), SaveStateDescriptorSlotComparator());

	return saveList;
}

void Decoder::decode(std::string inFileName,std::string outFileName,bool mode)
{
    //open input file
    std::string inName(inFileName);
    if (inName.rfind(".ebast",inName.size()-6) == std::string::npos) {
        std::cerr << "This isn't a ebast File" << std::endl;
        exit(1);
    }
    inFile.open(inFileName, std::ios::in | std::ios::binary);
    if (!inFile.is_open()) {
        std::cerr << "Unable to read File" << std::endl;
        exit(1);
    }
    
    //open output file
    std::string outName(outFileName);
    outName += ".txt";
    if(std::ifstream(outName.c_str()))
    {
        std::cerr<<outName<<" already exists!"<<std::endl;
        exit(1);
    }
    
    outFile.open(outName.c_str(),std::ios::out | std::ios::binary);
    if (!outFile.is_open()) {
        std::cerr << "Unable to create File" << std::endl;
        exit(1);
    }
    
    //reading frequency table from file
    huffmanTree->setRoot(readHeader());
    if (mode) {
        print(huffmanTree->getRoot());
    }
    //make file
    makeFile();
    
}

    int IfdMakerNote::read(const byte* buf,
                           long len,
                           long start,
                           ByteOrder byteOrder,
                           long shift)
    {
        // Remember the offset
        offset_ = start - shift;
        // Set byte order if none is set yet
        if (byteOrder_ == invalidByteOrder) byteOrder_ = byteOrder;
        // Read and check the header (and set offset adjustment)
        int rc = readHeader(buf + start, len - start, byteOrder);
        if (rc == 0) {
            rc = checkHeader();
        }
        // Adjust shift
        long newShift = absShift_ ? shift + shift_ : start + shift_;
        // Read the makernote IFD
        if (rc == 0) {
            rc = ifd_.read(buf, len, start + start_, byteOrder_, newShift);
        }
        if (rc == 0) {
            // IfdMakerNote currently does not support multiple IFDs
            if (ifd_.next() != 0) {
#ifndef SUPPRESS_WARNINGS
                std::cerr << "Warning: Makernote IFD has a next pointer != 0 ("
                          << ifd_.next()
                          << "). Ignored.\n";
#endif
            }
        }
#ifdef DEBUG_MAKERNOTE
        hexdump(std::cerr, buf + start, len - start);
        if (rc == 0) ifd_.print(std::cerr);
#endif

        return rc;
    } // IfdMakerNote::read

void GameApp::BuildLevel()
{
	ifstream infile("tilemap.txt");
	string line;
	while (getline(infile, line)) 
	{
			if (line == "[header]") 
			{
				if (!readHeader(infile)) 
				{
					return;
				}
			}
			else if (line == "[layer]") 
			{
				readLayerData(infile);
			}
			else if (line == "[Object Layer 1]") 
			{
				readEntityData(infile);
			}
	}
}

void ModelBinaryLoader::loadBinaryFile(std::string p_FilePath)
{
	clearData();
	std::ifstream input(p_FilePath, std::istream::in | std::istream::binary);
	if(!input)
	{
		throw std::runtime_error("File could not be opened: " + p_FilePath);
	}
	m_FileHeader = readHeader(&input);
	m_Material = readMaterial(m_FileHeader.m_NumMaterial,&input);
	if(m_FileHeader.m_Animated)
	{
		m_AnimationVertexBuffer = readVertexBufferAnimation(m_FileHeader.m_NumVertex, &input);
		calculateBoundingVolume(m_AnimationVertexBuffer);
	}
	else
	{
		m_VertexBuffer = readVertexBuffer(m_FileHeader.m_NumVertex, &input);
		calculateBoundingVolume(m_VertexBuffer);
	}
	m_MaterialBuffer = readMaterialBuffer(m_FileHeader.m_NumMaterialBuffer, &input);
	
}

bool MP3Stream::seek(const Timestamp &where) {
	if (where == _length) {
		_state = MP3_STATE_EOS;
		return true;
	} else if (where > _length) {
		return false;
	}

	const uint32 time = where.msecs();

	mad_timer_t destination;
	mad_timer_set(&destination, time / 1000, time % 1000, 1000);

	if (_state != MP3_STATE_READY || mad_timer_compare(destination, _totalTime) < 0)
		initStream();

	while (mad_timer_compare(destination, _totalTime) > 0 && _state != MP3_STATE_EOS)
		readHeader();

	decodeMP3Data();

	return (_state != MP3_STATE_EOS);
}

int 
recvFrom
(Peer *peer, byte *headerBuf, byte *dataBuf)
{	
	 	int headerSize = readHeader(peer, headerBuf, HEADERSIZE);
		
		if(headerSize == 0 )
		{
			printf("Non Header \n");
			return 0;
		}
 
		int length = byteToInt(headerBuf, 8);
		int dataSize   = readData(peer  , dataBuf,   length );

		printf("[ from %s ] type : %d, redesc : %d length : %d data : %s \n",
		 peer->ip, byteToInt(headerBuf,0),
                 byteToInt(headerBuf, 4),
                 byteToInt(headerBuf, 8),
                 dataBuf);

		return (headerSize + dataSize);
}

void decompress(InputStream& inputStream, OutputBuffer& output, header* pHeader) {

	header h;
	if (pHeader) {
		h = *pHeader;
	} else {
		readHeader(inputStream, h);
	}

	uint8* pInputBuffer	 = new uint8[h.fileSize];
	uint8* pOutputBuffer = new uint8[h.fileSize];

	ArithmeticDecoder	decoder(inputStream);
	StructuredModel		model(h.increments);
	model.decode(decoder, pInputBuffer, h.tempSize);

	iMTF(pInputBuffer, h.tempSize);
	iBWT(pInputBuffer, pOutputBuffer, h.tempSize, h.first);
	iRLE(pOutputBuffer, pInputBuffer, h.tempSize);

	output.setBuffer(pInputBuffer, h.fileSize);
	delete[] pOutputBuffer;
}

int readFile (char *filename, int *rows, int *cols, PIXEL** bitmap) 
{
  int fd, ret;
  unsigned int start;
  
  if(filename) {
    if((fd = open(filename, O_RDONLY)) < 0) {
      perror("Can't open bmp file to read");
      return -1;
    }
  } else fd = STDIN_FILENO;

  ret = readHeader (fd, rows, cols, &start);
  if(ret) return ret;

  *bitmap = (PIXEL*)malloc(sizeof(PIXEL)*(*rows)*(*cols));
  ret = readBits (fd, *bitmap, *rows, *cols, start);
  if(ret) return ret;

  if(filename) close(fd);

  return 0;
}

void MDNS::getResponses() {
  QueryHeader header = readHeader(buffer);

  if ((header.flags & 0x8000) == 0 && header.qdcount > 0) {
    uint8_t count = 0;

    while (count++ < header.qdcount && buffer->available() > 0) {
      Label * label = matcher->match(labels, buffer);

      if (buffer->available() >= 4) {
        uint16_t type = buffer->readUInt16();
        uint16_t cls = buffer->readUInt16();

        if (label != NULL) {

          label->matched(type, cls);
        }
      } else {
        status = "Buffer underflow at index " + buffer->getOffset();
      }
    }
  }
}

bool Table::rewind()
{
  xmlTextReaderPtr reader = NULL;

  if ( (reader = xmlNewTextReaderFilename(getName().c_str())) == NULL)
  {
    cout<<endl<<"Essai d'ouvrir "<< getName() <<endl;
    cout << "erreur fatale " << endl;
    return (false);
  }

  xmlTextReaderRead(reader);

  // initialisation du xmlReader
  setXmlReader(reader);
  // Utilise readHeader()
  readHeader();

  // le tuple courant est 0
  currentTuple = 0;

  return (true);
}

	//---------------------------------------------------------------------
	uint32 StreamSerialiser::peekNextChunkID()
	{
		checkStream();

		if (eof())
			return 0;

		// Have we figured out the endian mode yet?
		if (mReadWriteHeader)
			readHeader();

		if (mEndian == ENDIAN_AUTO)
			OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
			"Endian mode has not been determined, did you disable header without setting?", 
			"StreamSerialiser::peekNextChunkID");

		size_t homePos = mStream->tell();
		uint32 ret;
		read(&ret);
		mStream->seek(homePos);

		return ret;
	}

static void
readTemplate(template_t *t, tfile_t *tf)
{
	int magic;

	readScalar(magic, tf);
	assert(magic == TMPL_MAGIC);	/* Already checked by caller */
	readHeader(t, tf);
	readScalar(t->tm_flags, tf);
	t->tm_flags |= TMPL_TF_IMPORTED;
	readScalar(t->tm_alignment, tf);
	readScalar(t->tm_minsize, tf);
	readTemplateRefs(t, tf);
	if (tf->tf_errors) {
		/* Failed to import all structs we ref.  Bail out now. */
		return;
	}
	readAttributes(t, tf);
	if (isRedirectTmpl(t)) {
		readTmplRedirection(t, tf);
	}
	readTmplFormat(t, tf);
}

/* Write what is in the memPage to the pageNumth block.
 * The value of curPagePos was set to pageNum after writing.
 */
RC
writeBlock (int pageNum, SM_FileHandle *fHandle, SM_PageHandle memPage)
{
	FILE *fp;
	int totalNumPages;
	char *buff;

	if (access(fHandle->fileName, R_OK) < 0) return RC_FILE_NOT_FOUND;

	fp = fopen(fHandle->fileName, "r+");

	buff = (char*)malloc(sizeof(char)*PAGE_SIZE);

	if ((totalNumPages = readHeader(fp)) < 1) return RC_FILE_R_W_ERROR;
	
	//check if pageNum is valid 
	if ((pageNum >= totalNumPages) || (pageNum < 0)) return RC_READ_NON_EXISTING_PAGE;

	//read till the (pageNum - 1)th page
	int i;
	for (i = 0; i < pageNum; i++) {
		fread(buff, sizeof(char)*PAGE_SIZE, 1, fp);
	}
	
	//write memPage to the pageNum
	if (fwrite(memPage, sizeof(char)*PAGE_SIZE, 1, fp) < 1) return RC_WRITE_FAILED;
  // printf("WRITED TO DISK (page-%i): %s\n", pageNum, memPage);

  // printf("#### Writed page (%d) to disk! ####\n", pageNum);

	fHandle->curPagePos = pageNum;

	free(buff);
	fclose(fp);

	return RC_OK;
}

/* If the file has less than numberOfPages pages, then increase the size to numberOfPages. 
 * The increasing is done by appending (numberOfPages - totalNumPages) empty blocks 
 * at the end of file.
 */
RC
ensureCapacity (int numberOfPages, SM_FileHandle *fHandle)
{
    
    FILE *fp;
    int totalNumPages, i;
    char *buff;
    
    if (access(fHandle->fileName, R_OK) < 0) return RC_FILE_NOT_FOUND;
    
    fp = fopen(fHandle->fileName, "r+");
    
    buff = (char*)malloc(sizeof(char)*PAGE_SIZE);
    
    if ((totalNumPages = readHeader(fp)) < 1) return RC_FILE_R_W_ERROR;
    
    if (numberOfPages > totalNumPages) {
        for (i = 0; i < (numberOfPages - totalNumPages); i++) {
            appendEmptyBlock(fHandle);
        }
    }
    
    // log file info to console
    struct stat fileStat;
    if(stat(fHandle->fileName,&fileStat) < 0)
        return RC_FILE_R_W_ERROR;
    // printf("\n\n**ENSURE LOG**\n");
    // printf("************************************\n");
    // printf("File Name: \t\t%s\n",fHandle->fileName);
    // printf("File Size: \t\t%lld bytes\n",fileStat.st_size);
    // printf("Total # Pages: \t%d\n",fHandle->totalNumPages);
    
    free(buff);
    fclose(fp);

    return RC_OK;
}

RecordStorage::RecordStorage(int32_t maxRecordSize, char* fileName, int32_t id_msb, int32_t id_lsb, Stream* debugStream) {
	closed = false;
	debug = debugStream;
//	if(debug != NULL)
//	{
//		debug->print("Record Storage: ");
//		debug->println(fileName);
//		debug->print("Record Size: ");
//		debug->println(maxRecordSize);
//	}
	file_name = fileName;
	error_code = 0;
	header = NULL;

//	magic = HEADER_MAGIC_NUMBER;

	if (SD.exists(fileName) ) {
//		if(debug != NULL)
//		{
//			debug->print("Record File Size: ");
//			debug->println(store.size());
//		}
		readHeader();
		if(header->maxRecordSize != maxRecordSize)
		{
			error_code = error_code | ERROR_ROW_SIZE_MISMATCH;
		}
	} else {
		header = (RecordHeader*) calloc(sizeof(RecordHeader), 1);
		header->magicNumber = HEADER_MAGIC_NUMBER;
		header->maxRecordSize = maxRecordSize;
		header->uploaded = 0;
		header->id_lsb = id_lsb;
		header->id_msb = id_msb;
		writeHeader();
	}
}