//=============================================================================
//
//   File : KviFileUtils.cpp
//   Creation date : Fri Dec 25 1998 18:26:48 by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 1998-2010 Szymon Stefanek (pragma at kvirc dot net)
//
//   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 2
//   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, write to the Free Software Foundation,
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#define _KVI_FILEUTLIS_CPP_

#include "KviFileUtils.h"
#include "KviQString.h"
#include "KviFile.h"
#include "KviMemory.h"

#include <QDir>
#include <QFileInfo>
#include <QString>
#include <QStringList>
#include <QtGlobal>
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
#include <QTextCodec>
#else
#include <QStringConverter>
#endif
#include <QTextStream>

namespace KviFileUtils
{
	static char cHexChars[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

	bool makeDir(const QString & szPath)
	{
		QDir d;
		QString szDir = szPath.trimmed();
		adjustFilePath(szDir);
		QString szCreatedDir;

#if defined(COMPILE_ON_WINDOWS) || defined(COMPILE_ON_MINGW)
		int idx = szDir.indexOf(':');
		if(idx == 1)
		{
			szCreatedDir = szDir.left(2);
			szDir.remove(0, 2);
		}
#endif

		KviQString::stripLeft(szDir, KVI_PATH_SEPARATOR_CHAR);
		while(!szDir.isEmpty())
		{
			szCreatedDir += KVI_PATH_SEPARATOR;
			szCreatedDir += KviQString::getToken(szDir, KVI_PATH_SEPARATOR_CHAR);
			if(!directoryExists(szCreatedDir))
			{
				if(!d.mkdir(szCreatedDir))
				{
					qDebug("Can't create directory %s", szCreatedDir.toUtf8().data());
					return false;
				}
			}
			KviQString::stripLeft(szDir, KVI_PATH_SEPARATOR_CHAR);
		}
		return true;
	}

	bool makeDir(const char * pcPath)
	{
		QString szPath = QString::fromUtf8(pcPath);
		return makeDir(szPath);
	}

	bool renameFile(const QString & szSrc, const QString & szDst)
	{
		QDir d;
		return d.rename(szSrc, szDst);
	}

	bool renameFile(const char * pcSrc, const char * pcDst)
	{
		QString szPath = QString::fromUtf8(pcSrc);
		QString szPath2 = QString::fromUtf8(pcDst);
		return renameFile(szPath, szPath2);
	}

	bool copyFile(const QString & szSrc, const QString & szDst)
	{
		KviFile f1(szSrc);
		if(!f1.open(QFile::ReadOnly))
			return false;
		KviFile f2(szDst);
		if(!f2.open(QFile::WriteOnly | QFile::Truncate))
		{
			f1.close();
			return false;
		}
		char cBuffer[1024];
		while(!f1.atEnd())
		{
			int iLen = f1.read(cBuffer, 1024);
			if(iLen <= 0)
			{
				f1.close();
				f2.close();
				return false; //"serious error"
			}
			f2.write(cBuffer, iLen);
		}
		f1.close();
		f2.close();
		return true;
	}

	bool copyFile(const char * pcSrc, const char * pcDst)
	{
		QString szPath = QString::fromUtf8(pcSrc);
		QString szPath2 = QString::fromUtf8(pcDst);
		return copyFile(szPath, szPath2);
	}

	bool loadFile(const QString & szPath, QString & szBuffer, bool bUtf8)
	{
		KviFile f(szPath);
		if(!f.open(QFile::ReadOnly))
			return false;
		if(bUtf8)
		{
			QByteArray ba = f.readAll();
			szBuffer = QString::fromUtf8(ba.data(), ba.size());
			//qDebug("BUFFERLEN: %d",szBuffer.length());
		}
		else
		{
			szBuffer = QString(f.readAll());
		}
		return true;
	}

	void adjustFilePath(QString & szPath)
	{
#if defined(COMPILE_ON_WINDOWS) || defined(COMPILE_ON_MINGW)
		szPath.replace('/', "\\");
		szPath.replace("\\\\", "\\");
		// FIXME: Use the default drive here ?
		if(szPath.startsWith("\\"))
			szPath.prepend("C:");
#else
		szPath.replace('\\', "/");
		szPath.replace("//", "/");
		// deal with windows paths
		if((szPath.length() > 2) && (szPath.at(0) != QChar('/')))
		{
			if((szPath.at(1) == QChar(':')) && (szPath.at(2) == QChar('/')))
			{
				szPath.remove(0, 2);
			}
		}
		szPath = QDir::cleanPath(szPath);
#endif
	}

	bool removeFile(const QString & szPath)
	{
		QDir d;
		return d.remove(szPath);
	}

	bool removeFile(const char * pcPath)
	{
		QString szPath = QString::fromUtf8(pcPath);
		return removeFile(szPath);
	}

	bool removeDir(const QString & szPath)
	{
		QDir d;
		return d.rmdir(szPath);
	}

	bool removeDir(const char * pcPath)
	{
		QString szPath = QString::fromUtf8(pcPath);
		return removeDir(szPath);
	}

	bool deleteDir(const QString & szPath)
	{
		QDir d(szPath);

		QFileInfoList lFileInfo = d.entryInfoList(QDir::Files | QDir::Dirs | QDir::Hidden | QDir::System | QDir::NoDotAndDotDot);

		for(const auto & inf : lFileInfo)
		{
			// just to be sure check that we're not deleting ..
			if(KviQString::equalCS(inf.fileName(), "..") || KviQString::equalCS(inf.fileName(), "."))
				continue;

			if(inf.isDir())
			{
				if(!deleteDir(inf.absoluteFilePath()))
					return false;
				continue;
			}

			if(!KviFileUtils::removeFile(inf.absoluteFilePath()))
			{
				qDebug("Failed to remove file %s", inf.absoluteFilePath().toUtf8().data());
				return false;
			}
		}

		if(!KviFileUtils::removeDir(szPath))
		{
			qDebug("Failed to remove directory %s", szPath.toUtf8().data());
			return false;
		}

		return true;
	}

	bool writeFile(const QString & szPath, const QByteArray & oData, bool bAppend)
	{
		KviFile f(szPath);
		if(!f.open(QFile::WriteOnly | (bAppend ? QFile::Append : QFile::Truncate)))
			return false;
		if(oData.length() < 1)
			return true;
		if(f.write(oData.data(), oData.length()) != ((unsigned int)(oData.length())))
			return false;
		return true;
	}

	bool writeFile(const QString & szPath, const QString & szData, bool bAppend)
	{
		KviFile f(szPath);
		if(!f.open(QFile::WriteOnly | (bAppend ? QFile::Append : QFile::Truncate)))
			return false;
		QByteArray szTmp = szData.toUtf8();
		if(f.write(szTmp.data(), szTmp.length()) != ((unsigned int)(szTmp.length())))
			return false;
		return true;
	}

	bool writeFile(const char * pcPath, const QString & szData, bool bAppend)
	{
		QString szPath = QString::fromUtf8(pcPath);
		return writeFile(szPath, szData, bAppend);
	}

	bool writeFileLocal8Bit(const QString & szPath, const QString & szData, bool bAppend)
	{
		KviFile f(szPath);
		if(!f.open(QFile::WriteOnly | (bAppend ? QFile::Append : QFile::Truncate)))
			return false;
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
		QByteArray szTmp = QTextCodec::codecForLocale()->fromUnicode(szData);
#else
		QStringEncoder enc = QStringEncoder(QStringConverter::Latin1);
		QByteArray szTmp = enc.encode(szData);
#endif

		if(f.write(szTmp.data(), szTmp.length()) != ((unsigned int)(szTmp.length())))
			return false;
		return true;
	}

	bool writeFileLocal8Bit(const char * pcPath, const QString & szData, bool bAppend)
	{
		QString szPath = QString::fromUtf8(pcPath);
		return writeFileLocal8Bit(szPath, szData, bAppend);
	}

	bool readFile(const QString & szPath, QString & szBuffer, unsigned int uMaxSize)
	{
		KviFile f(szPath);
		if(!f.open(QFile::ReadOnly))
			return false;
		if(f.size() < 1)
		{
			szBuffer = "";
			f.close();
			return true;
		}
		if(f.size() > uMaxSize)
			return false;
		char * pcBuf = new char[f.size() + 1];
		if(f.read(pcBuf, f.size()) != ((long int)f.size()))
		{
			delete[] pcBuf;
			pcBuf = nullptr;
			return false;
		}
		pcBuf[f.size()] = '\0';
		szBuffer = QString::fromUtf8(pcBuf);
		delete[] pcBuf;
		pcBuf = nullptr;
		return true;
	}

	bool readFile(const char * pcPath, QString & szBuffer, unsigned int uMaxSize)
	{
		QString szPath = QString::fromUtf8(pcPath);
		return readFile(szPath, szBuffer, uMaxSize);
	}

	QString extractFileName(const QString & szFileNameWithPath, bool bAllowEmpty)
	{
		if(!bAllowEmpty)
		{
			if(szFileNameWithPath.endsWith(KVI_PATH_SEPARATOR))
				return QFileInfo(szFileNameWithPath.left(szFileNameWithPath.length() - 1)).fileName();
		}
		return QFileInfo(szFileNameWithPath).fileName();
	}

	QString extractFilePath(const QString & szFileNameWithPath)
	{
		return QFileInfo(szFileNameWithPath).absolutePath();
	}

	bool readLine(QFile * pFile, QString & szBuffer, bool bUtf8)
	{
		QTextStream stream(pFile);
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
		/*
		* Name: UTF-8
		* MIBenum: 106
		* from: http://www.iana.org/assignments/character-sets
		*/
    	stream.setCodec(bUtf8 ? QTextCodec::codecForMib(106) : QTextCodec::codecForLocale());
#else
		stream.setEncoding(bUtf8 ? QStringConverter::Utf8 : QStringConverter::Latin1);
#endif
		szBuffer = stream.readLine();
		return !szBuffer.isNull();
	}

	bool readLines(QFile * pFile, QStringList & buffer, int iStartLine, int iCount, bool bUtf8)
	{
		QTextStream stream(pFile);
#if (QT_VERSION < QT_VERSION_CHECK(6, 0, 0))
		//please read comments in the readLine(...) method
    	stream.setCodec(bUtf8 ? QTextCodec::codecForMib(106) : QTextCodec::codecForLocale());
#else
		stream.setEncoding(bUtf8 ? QStringConverter::Utf8 : QStringConverter::Latin1);
#endif

		for(int i = 0; i < iStartLine; i++)
			stream.readLine();

		if(iCount > 0)
		{
			for(; (iCount > 0 && !stream.atEnd()); iCount--)
				buffer.append(stream.readLine());
		}
		else
		{
			while(!stream.atEnd())
			{
				buffer.append(stream.readLine());
			}
		}
		return buffer.count() != 0;
	}

	bool directoryExists(const QString & szPath)
	{
		QFileInfo f(szPath);
		return (f.exists() && f.isDir());
	}

	bool isReadable(const QString & szFname)
	{
		QFileInfo f(szFname);
		return (f.exists() && f.isFile() && f.isReadable());
	}

	bool isReadable(const char * pcPath)
	{
		QString szPath = QString::fromUtf8(pcPath);
		return isReadable(szPath);
	}

	bool isAbsolutePath(const QString & szPath)
	{
		QFileInfo f(szPath);
		return !f.isRelative();
	}

	void encodeFileName(QString & szPath)
	{
		QString szSrc(szPath);
		szPath = "";
		for(const auto & i : szSrc)
		{
			QChar cur = i;
			if(!(cur.isLetter() || cur.isDigit() || cur == ' ' || cur == '_' || cur == '.' || cur == '#' || cur == '%'))
			{
				if(cur.row() != 0)
				{
					szPath += '%';
					szPath += cHexChars[cur.row() >> 4];
					szPath += cHexChars[cur.row() & 15];
				}
				szPath += '%';
				szPath += cHexChars[cur.cell() >> 4];
				szPath += cHexChars[cur.cell() & 15];
			}
			else if(cur == '%')
			{
				szPath += "%%";
			}
			else
			{
				szPath += cur;
			}
		}
	}

	void cleanFileName(QString & szPath)
	{
		QString szSrc(szPath);
		szPath = "";
		for(const auto & i : szSrc)
		{
			QChar cur = i;
#if defined(COMPILE_ON_WINDOWS) || defined(COMPILE_ON_MINGW)
			if(cur.unicode() < 32 || cur == '<' || cur == '>' || cur == ':' || cur == '"' || cur == '/' || cur == '\\' || cur == '|' || cur == '?' || cur == '*')
#else
			if(cur.unicode() == 0 || cur == '/')
#endif
			{
				szPath += '-';
			}
			else
			{
				szPath += cur;
			}
		}
	}

	static QStringList getFileListingInternal(const QString & szPath, const QString & szPrefix)
	{
		//qDebug("Scan %s",szPath.toUtf8().data());
		QStringList sl;

		QDir d(szPath);

		QFileInfoList fl = d.entryInfoList(QStringList(), QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot, QDir::Name);

		for(const auto & inf : fl)
		{
			QString szName = szPrefix.isEmpty() ? inf.fileName() : QString("%1" KVI_PATH_SEPARATOR "%2").arg(szPrefix).arg(inf.fileName());
			if(inf.isDir())
			{
				QStringList sub = getFileListingInternal(inf.canonicalFilePath(), szName);
				sl.append(sub);
			}
			else
			{
				sl.append(szName);
			}
		}

		return sl;
	}

	QStringList getFileListing(const QString & szPath)
	{
		return getFileListingInternal(szPath, QString());
	}
}