/*
    PIP - Platform Independent Primitives
    File
    Copyright (C) 2013  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 "piiodevice.h"
#include <cstdio>

/// handlers:
/// void clear()
/// void resize(llong new_size, char fill = 0)
/// void remove()
class PIFile: public PIIODevice
{
public:
	PIFile(const PIString & path = PIString(), DeviceMode type = ReadWrite): PIIODevice(path, type) {setPrecision(5); openDevice();}

	//PIFile & operator =(const PIFile & f) {path_ = f.path_; type_ = f.type_; return *this;}

	void flush() {fflush(fd);}
	EVENT_HANDLER(PIFile, void, clear) {close(); fd = fopen(path_.data(), "w"); close(); open();}
	void seek(llong position) {if (!opened_) return; fseek(fd, position, SEEK_SET); clearerr(fd);}
	void seekToBegin() {if (!opened_) return; fseek(fd, 0, SEEK_SET); clearerr(fd);}
	void seekToEnd() {if (!opened_) return; fseek(fd, 0, SEEK_END); clearerr(fd);}
	void seekToLine(llong line) {if (!opened_) return; seekToBegin(); piForTimes (line) readLine(); clearerr(fd);} // 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);}
	char readChar() {return (char)fgetc(fd);}
	PIString readLine();
	llong readAll(void * data);
	PIByteArray readAll(bool forceRead = false);
	EVENT_HANDLER0(PIFile, void, remove) {close(); std::remove(path_.data());}

	void setPath(const PIString & path) {path_ = path; if (opened_) openDevice();}
	llong size();
	llong pos() {if (!opened_) return -1; return ftell(fd);}
	bool isEnd() {if (!opened_) return true; return (feof(fd) || ferror(fd));}
	bool isEmpty() {return (size() <= 0);}

	int precision() const {return prec;}
	void setPrecision(int prec_) {prec = prec_; prec_str = "." + itos(prec_);}

	int read(void * read_to, int max_size) {if (!canRead()) return -1; return fread(read_to, max_size, 1, fd);}
	int write(const void * data, int max_size) {if (!canWrite()) return -1; return fwrite(data, max_size, 1, fd);}
	PIFile & writeToBinLog(ushort id, const void * data, int size) {if (!isWriteable()) return *this; writeBinary(id).writeBinary((ushort)size); write(data, size); flush(); return *this;}

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

	PIFile & operator <<(const char & v) {if (!isWriteable()) return *this; write(&v, 1); return *this;}
	//PIFile & operator <<(const string & v) {write(v.c_str(), v.size()); return *this;}
	PIFile & operator <<(const PIString & v) {if (!isWriteable()) return *this; write(v.data(), v.lengthAscii()); return *this;}
	PIFile & operator <<(const PIByteArray & v) {if (!isWriteable()) return *this; write(v.data(), v.size()); return *this;}
	PIFile & operator <<(short v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%hd", v); return *this;}
	PIFile & operator <<(int v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%d", v); return *this;}
	PIFile & operator <<(long v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%ld", v); return *this;}
	PIFile & operator <<(llong v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%lld", v); return *this;}
	PIFile & operator <<(uchar v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%c", v); return *this;}
	PIFile & operator <<(ushort v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%hd", v); return *this;}
	PIFile & operator <<(uint v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%d", v); return *this;}
	PIFile & operator <<(ulong v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%ld", v); return *this;}
	PIFile & operator <<(ullong v) {if (!isWriteable()) return *this; ret = fprintf(fd, "%lld", v); return *this;}
	PIFile & operator <<(float v) {if (!isWriteable()) return *this; ret = fprintf(fd, ("%" + prec_str + "f").c_str(), v); return *this;}
	PIFile & operator <<(double v) {if (!isWriteable()) return *this; ret = fprintf(fd, ("%" + prec_str + "lf").c_str(), v); return *this;}

	PIFile & operator >>(char & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%hhn", &v); return *this;}
	PIFile & operator >>(short & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%hn", &v); return *this;}
	PIFile & operator >>(int & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%n", &v); return *this;}
	PIFile & operator >>(long & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%ln", &v); return *this;}
	PIFile & operator >>(llong & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%lln", &v); return *this;}
	PIFile & operator >>(uchar & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%hhn", &v); return *this;}
	PIFile & operator >>(ushort & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%hn", &v); return *this;}
	PIFile & operator >>(uint & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%n", &v); return *this;}
	PIFile & operator >>(ulong & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%ln", &v); return *this;}
	PIFile & operator >>(ullong & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%lln", &v); return *this;}
	PIFile & operator >>(float & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%f", &v); return *this;}
	PIFile & operator >>(double & v) {if (!isWriteable()) return *this; ret = fscanf(fd, "%lf", &v); return *this;}

	static PIFile openTemporary(PIIODevice::DeviceMode mode = PIIODevice::ReadWrite) {return PIFile(PIString(tmpnam(0)), mode);}
	static bool isExists(const PIString & path);
	static bool remove(const PIString & path) {return std::remove(path.data()) == 0;}

protected:
	bool openDevice();
	bool closeDevice();

private:
	PIString strType(const PIIODevice::DeviceMode type) {switch (type) {case PIIODevice::ReadOnly: return "rb"; case WriteOnly: return "ab"; case ReadWrite: return "a+b";} return "rb";}

	FILE * fd;
	int ret, prec;
	string prec_str;

};

#endif // PIFILE_H