/*
    PIP - Platform Independent Primitives
    File
    Copyright (C) 2011  Ivan Pelipenko peri4ko@gmail.com

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef PIFILE_H
#define PIFILE_H

#include "piobject.h"
#include <fstream>

using std::fstream;

class PIFile: public PIObject
{
public:
	PIFile(): PIObject() {;}

	enum Mode {Read = fstream::in, Write = fstream::out, Truncate = fstream::trunc, New = fstream::app, ReadWrite = Read | Write};

	PIFile(const PIString & path, PIFlags<Mode> mode = ReadWrite): PIObject(path) {open(path, mode);}
	PIFile(const PIFile & file): PIObject(file.cpath) {cpath = file.cpath; cmode = file.cmode;}
	~PIFile() {close();}
	
	PIFile & operator =(const PIFile & f) {cpath = f.cpath; cmode = f.cmode; return *this;}

	EVENT_HANDLER2(PIFile, bool, open, const PIString & , path, PIFlags<Mode>, mode);
	EVENT_HANDLER1(PIFile, bool, open, PIFlags<Mode>, mode) {return open(cpath, mode);}
	EVENT_HANDLER1(PIFile, bool, open, const PIString & , path) {return open(path, cmode);}
	EVENT_HANDLER0(PIFile, bool, open) {return open(cpath, cmode);}
	EVENT_HANDLER0(PIFile, void, close) {stream.clear(); stream.close();}
	EVENT_HANDLER0(PIFile, void, clear) {string st = cpath.stdString(); close(); stream.open(st.c_str(), fstream::trunc | fstream::binary | (fstream::openmode)(int)cmode);}
	void seek(llong position) {stream.clear(); stream.seekg(position); stream.seekp(position);}
	void seekToBegin() {stream.clear(); stream.seekg(0, fstream::beg); stream.seekp(0, fstream::beg);}
	void seekToEnd() {stream.clear(); stream.seekg(0, fstream::end); stream.seekp(0, fstream::end);}
	void seekToLine(llong line) {stream.clear(); seekToBegin(); piForTimes (line) readLine();} // line 0 - begin of file
	EVENT_HANDLER1(PIFile, void, resize, llong, new_size) {resize(new_size, 0);}
	EVENT_HANDLER2(PIFile, void, resize, llong, new_size, char, fill);
	void fill(char c) {stream.fill(c);}
	EVENT_HANDLER0(PIFile, void, flush) {stream.flush();}
	PIString readLine();
	llong readAll(void * data);
	PIByteArray readAll(bool forceRead = false);
	EVENT_HANDLER0(PIFile, void, remove) {close(); std::remove(cpath.data());}

	PIString path() const {return cpath;}
	void setPath(const PIString & path) {cpath = path;}
	PIFlags<Mode> mode() const {return cmode;}
	llong size();
	llong pos();
	bool isOpened() {return stream.is_open();}
	bool isEnd() {return stream.eof();}
	bool isEmpty() {return (size() <= 0);}

	PIFile & writeData(const void * data, int size_) {stream.write((char * )data, size_); return *this;}
	PIFile & readData(void * data, int size_) {stream.read((char * )data, size_); return *this;}
	PIFile & writeToBinLog(ushort id, const void * data, int size) {writeBinary(id).writeBinary((ushort)size).writeData(data, size); flush(); return *this;}

	PIFile & writeBinary(const char v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const short v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const int v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const long v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const uchar v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const ushort v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const uint v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const ulong v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const float v) {stream.write((char * )&v, sizeof(v)); return *this;}
	PIFile & writeBinary(const double v) {stream.write((char * )&v, sizeof(v)); return *this;}

	PIFile & operator <<(const char & v) {stream.write(&v, 1); return *this;}
	//PIFile & operator <<(const string & v) {stream.write(v.c_str(), v.size()); return *this;}
	PIFile & operator <<(const PIString & v) {string s = v.stdString(); stream.write(s.c_str(), s.size()); return *this;}
	PIFile & operator <<(const PIByteArray & v) {stream.write((char * )v.data(), v.size()); return *this;}
	PIFile & operator <<(const short & v) {stream << v; return *this;}
	PIFile & operator <<(const int & v) {stream << v; return *this;}
	PIFile & operator <<(const long & v) {stream << v; return *this;}
	PIFile & operator <<(const uchar & v) {stream << v; return *this;}
	PIFile & operator <<(const ushort & v) {stream << v; return *this;}
	PIFile & operator <<(const uint & v) {stream << v; return *this;}
	PIFile & operator <<(const ulong & v) {stream << v; return *this;}
	PIFile & operator <<(const float & v) {stream << v; return *this;}
	PIFile & operator <<(const double & v) {stream << v; return *this;}

	PIFile & operator >>(char & v) {stream >> v; return *this;}
	PIFile & operator >>(short & v) {stream >> v; return *this;}
	PIFile & operator >>(int & v) {stream >> v; return *this;}
	PIFile & operator >>(long & v) {stream >> v; return *this;}
	PIFile & operator >>(uchar & v) {stream >> v; return *this;}
	PIFile & operator >>(ushort & v) {stream >> v; return *this;}
	PIFile & operator >>(uint & v) {stream >> v; return *this;}
	PIFile & operator >>(ulong & v) {stream >> v; return *this;}
	PIFile & operator >>(float & v) {stream >> v; return *this;}
	PIFile & operator >>(double & v) {stream >> v; return *this;}
	
	static PIFile openTemporary(PIFlags<PIFile::Mode> mode = PIFile::ReadWrite);
	static bool isExists(const PIString & path) {return std::ifstream(path.stdString().c_str()).good();}
	static bool remove(const PIString & path) {return std::remove(path.stdString().c_str()) == 0;}

private:
	fstream stream;
	PIString cpath;
	PIFlags<Mode> cmode;

};

#endif // PIFILE_H