#ifndef MYX_BASE_PATHS_CPP_
#define MYX_BASE_PATHS_CPP_

#ifndef MYXLIB_HEADER_ONLY
#include <myx/filesystem/paths.hpp>
#else
#pragma once
#endif

#include <myx/base/config.hpp>
#include <myx/filesystem/current_executable.hpp>

#include <paths.h>

#include <QCoreApplication>
#include <QString>

namespace myx {

namespace filesystem {

MYXLIB_INLINE Paths::Paths() = default;


MYXLIB_INLINE void Paths::setupSystemDirectories( const QString& defaultEtcDirectory,
                                                  const QString& defaultConstDataDirectory,
                                                  const QString& defaultVarDataDirectory,
                                                  const QString& defaultLogDirectory )
{
	QFileInfo etcDirInfo { defaultEtcDirectory };
	if ( etcDirInfo.isDir() && etcDirInfo.isReadable() )
	{
		m_systemConfigDirectory = defaultEtcDirectory;
	}
	else
	{
		m_systemConfigDirectory = m_userConfigDirectory;
	}

	QFileInfo constDataDirInfo { defaultConstDataDirectory };
	if ( constDataDirInfo.isDir() && constDataDirInfo.isReadable() )
	{
		m_systemConstDataDirectory = defaultConstDataDirectory;
	}
	else
	{
		m_systemConstDataDirectory = m_userConstDataDirectory;
	}

	QFileInfo varDataDirInfo { defaultVarDataDirectory };
	if ( varDataDirInfo.isDir() && varDataDirInfo.isWritable() )
	{
		m_systemVarDataDirectory = defaultVarDataDirectory;
	}
	else
	{
		m_systemVarDataDirectory = m_userVarDataDirectory;
	}

	QFileInfo logDirInfo { defaultLogDirectory };
	if ( logDirInfo.isDir() && logDirInfo.isWritable() )
	{
		m_systemLogDirectory = defaultLogDirectory;
	}
	else
	{
		m_systemLogDirectory = m_userLogDirectory;
	}
} // Paths::setupSystemDirectories


Paths::HierarchyType Paths::getHierarchyType()
{
	QRegExp binUnityRegexp( "/s*bin/unity$" );
	auto binaryDir = m_executableDirectory;

	if ( binUnityRegexp.indexIn( binaryDir ) >= 0 )
	{
		binaryDir.remove( binUnityRegexp );
		setupSystemDirectories( binaryDir + "/etc",
		                        binaryDir + "/files/data",
		                        binaryDir + "/files/lib",
		                        binaryDir + "/files/log" );

		return ( HierarchyType::kDevelopment );
	}

	QRegExp binRegexp( "/s*bin$" );
	if ( binRegexp.indexIn( binaryDir ) == -1 )
	{
		m_systemConstDataDirectory = m_executableDirectory;
		m_systemVarDataDirectory   = m_executableDirectory;
		m_systemConfigDirectory    = m_executableDirectory;
		m_systemLogDirectory       = m_executableDirectory;

		return ( HierarchyType::kFlat );
	}

	QRegExp optRegexp( "^/opt(/|/.+/)" + m_projectName + "/" );
	if ( optRegexp.indexIn( binaryDir )  >= 0 )
	{
		binaryDir.remove( binRegexp );
		setupSystemDirectories( binaryDir + "/etc",
		                        binaryDir + "/files/data",
		                        binaryDir + "/files/lib",
		                        binaryDir + "/files/log" );

		return ( HierarchyType::kOpt );
	}

	if ( binaryDir.startsWith( QStringLiteral( "/usr/local" ) ) )
	{
		setupSystemDirectories( "/usr/local/etc/" + m_projectName,
		                        "/usr/local/share/" + m_projectName,
		                        "/var/lib/" + m_projectName,
		                        "/var/log/" + m_projectName );

		return ( HierarchyType::kUsr );
	}

	if ( binaryDir.startsWith( QStringLiteral( "/usr" ) ) )
	{
		setupSystemDirectories( "/etc/" + m_projectName,
		                        "/usr/share/" + m_projectName,
		                        "/var/lib/" + m_projectName,
		                        "/var/log/" + m_projectName );

		return ( HierarchyType::kUsr );
	}

	if ( binaryDir.startsWith( m_homeDirectory + "/.local/bin" ) ||
	     binaryDir.startsWith( m_homeDirectory + "/bin" ) )
	{
		m_systemConfigDirectory    = m_userConfigDirectory;
		m_systemConstDataDirectory = m_userConstDataDirectory;
		m_systemVarDataDirectory   = m_userVarDataDirectory;
		m_systemLogDirectory       = m_userLogDirectory;

		return( HierarchyType::kHome );
	}

	binaryDir.remove( binRegexp );
	setupSystemDirectories( binaryDir + "/etc",
	                        binaryDir + "/files/data",
	                        binaryDir + "/files/lib",
	                        binaryDir + "/files/log" );

	return ( HierarchyType::kDevelopment );
} // Paths::getHierarchyType


MYXLIB_INLINE bool Paths::init( const QString& projectDir, const QString& configFileExtension )
{
	CurrentExecutable exe;
	m_executableName      = exe.m_canonicalFilePath.fileName();
	m_executableFilePath  = exe.m_canonicalFilePath.absoluteFilePath();
	m_executableDirectory = exe.m_canonicalFilePath.absolutePath();

	m_projectName = projectDir.isEmpty() ? m_executableName
	                                     : projectDir;
	m_configFileExtension = configFileExtension.isEmpty() ? QStringLiteral( "conf" )
	                                                      : configFileExtension;
	m_configFileName = m_projectName + "." + m_configFileExtension;

	m_homeDirectory = QDir::homePath();
	m_tempDirectory = QDir::tempPath();

	auto configHome = QString::fromLocal8Bit( qgetenv( "XDG_CONFIG_HOME" ) );
	if ( configHome.isEmpty() )
	{
		configHome = m_homeDirectory + "/.config";
	}
	m_userConfigDirectory = configHome + "/" + m_projectName;

	auto dataHome = QString::fromLocal8Bit( qgetenv( "XDG_DATA_HOME" ) );
	if ( dataHome.isEmpty() )
	{
		dataHome = m_homeDirectory + "/.local/share";
	}
	dataHome                += "/" + m_projectName;
	m_userConstDataDirectory = dataHome + "/data";
	m_userVarDataDirectory   = dataHome + "/lib";
	m_userLogDirectory       = dataHome + "/log";

	m_hierarchyType = getHierarchyType();

	m_configFilePath = m_systemConfigDirectory + "/" + m_configFileName;

	return( true );
} // Paths::updatePaths


MYXLIB_INLINE bool Paths::makeDefaultDirectories()
{
	bool status = true;
	QDir dir;

	if ( dir.mkpath( m_userConfigDirectory ) ) { status = false; }
	if ( dir.mkpath( m_userVarDataDirectory ) ) { status = false; }
	if ( dir.mkpath( m_userConstDataDirectory ) ) { status = false; }
	if ( dir.mkpath( m_userLogDirectory ) ) { status = false; }
	if ( dir.mkpath( m_systemConfigDirectory ) ) { status = false; }
	if ( dir.mkpath( m_systemVarDataDirectory ) ) { status = false; }
	if ( dir.mkpath( m_systemConstDataDirectory ) ) { status = false; }
	if ( dir.mkpath( m_systemLogDirectory ) ) { status = false; }

	return( status );
}


MYXLIB_INLINE QString Paths::findConfigFile( const QString& defaultConfigFile )
{
	if ( !defaultConfigFile.isEmpty() && QFileInfo( defaultConfigFile ).isReadable() )
	{
		m_configFilePath = defaultConfigFile;
		return( defaultConfigFile );
	}

	auto fileName = QString::fromLocal8Bit( qgetenv( QCoreApplication::applicationName()
	                                                 .toUpper().toUtf8() + "_CONFIG" ) );
	if ( QFileInfo( fileName ).isReadable() )
	{
		m_configFilePath = fileName;
		return( fileName );
	}

	if ( QFileInfo( m_configFilePath ).isReadable() )
	{
		return( m_configFilePath );
	}

	return( QString() );
} // Paths::findConfigFile


MYXLIB_INLINE const QString& Paths::userConfigDirectory() const
{
	return( m_userConfigDirectory );
}


MYXLIB_INLINE const QString& Paths::systemConfigDirectory() const
{
	return( m_systemConfigDirectory );
}


MYXLIB_INLINE const QString& Paths::configFilePath() const
{
	return( m_configFilePath );
}


MYXLIB_INLINE const QString& Paths::configFileName() const
{
	return( m_configFileName );
}


MYXLIB_INLINE const QString& Paths::configFileExtension() const
{
	return( m_configFileExtension );
}


MYXLIB_INLINE const QString& Paths::userVarDataDirectory() const
{
	return( m_userVarDataDirectory );
}


MYXLIB_INLINE const QString& Paths::systemVarDataDirectory() const
{
	return( m_systemVarDataDirectory );
}


MYXLIB_INLINE const QString& Paths::userConstDataDirectory() const
{
	return( m_userConstDataDirectory );
}


MYXLIB_INLINE const QString& Paths::systemConstDataDirectory() const
{
	return( m_systemConstDataDirectory );
}


MYXLIB_INLINE const QString& Paths::userLogDirectory() const
{
	return( m_userLogDirectory );
}


MYXLIB_INLINE const QString& Paths::systemLogDirectory() const
{
	return( m_systemLogDirectory );
}


MYXLIB_INLINE const QString& Paths::tempDirectory() const
{
	return( m_tempDirectory );
}


MYXLIB_INLINE const QString& Paths::homeDirectory() const
{
	return( m_homeDirectory );
}


MYXLIB_INLINE const QString& Paths::projectName() const
{
	return( m_projectName );
}


MYXLIB_INLINE const QString& Paths::executableName() const
{
	return( m_executableName );
}


MYXLIB_INLINE const QString& Paths::executableFilePath() const
{
	return( m_executableFilePath );
}


MYXLIB_INLINE const QString& Paths::executableDirectory() const
{
	return( m_executableDirectory );
}

} // namespace filesystem

} // namespace myx

#endif // MYX_BASE_PATHS_CPP_