/**

 * Relational pipes

 * Copyright © 2018 František Kučera (Frantovo.cz, GlobalCode.info)

 *

 * 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/>.

 */

#pragma once

#include <cstdlib>

#include <iostream>

#include <string>

#include <vector>

#include <array>

#include <algorithm>

#include <filesystem>

#include <pwd.h>

#include <grp.h>

#include <sys/stat.h>

#include <sys/xattr.h>

#include <relpipe/writer/typedefs.h>

namespace relpipe {

namespace in {

namespace filesystem {

namespace fs = std::filesystem;

using namespace relpipe::writer;

class FilesystemCommand {

	std::wstring_convert<codecvt_utf8<wchar_t>> convertor; // TODO: support also other encodings.

	void reset(std::stringstream& stream) {

		stream.str("");

		stream.clear();

	}

	bool readNext(std::istream& input, std::stringstream& originalName) {

		for (char ch; input.get(ch);) {

			if (ch == 0) return true;

			else originalName << ch;

		}

		return originalName.tellp();

	}

	string_t getType(const fs::path& file) {

		// TODO: Use whole words? (letters are compatible with find -type)

		if (fs::is_regular_file(file)) return L"f";

		else if (fs::is_symlink(file)) return L"l"; // symlinks to directories are both symlinks and directories

		else if (fs::is_directory(file)) return L"d";

		else if (fs::is_fifo(file)) return L"p";

		else if (fs::is_socket(file)) return L"s";

		else if (fs::is_block_file(file)) return L"b";

		else if (fs::is_character_file(file)) return L"c";

		else return L"o";

	}

	void fetchOwner(const fs::path& file, string_t& owner, string_t& group) {

		// TODO: throw exception on error

		// TODO: get user and group in C++ way?

		struct stat info;

		stat(file.c_str(), &info);

		/**

		 * The return value may point to a static area, and may  be

		 * overwritten  by  subsequent calls to getpwent(3), getpw‐

		 * nam(), or getpwuid().  (Do not pass the returned pointer

		 * to free(3).)

		 */

		struct passwd* pw = getpwuid(info.st_uid);

		struct group* gr = getgrgid(info.st_gid);

		owner = convertor.from_bytes(pw->pw_name);

		group = convertor.from_bytes(gr->gr_name);

	}

	string_t getXattr(const fs::path& file, const string_t& attributeName) {

		// TODO: review, test on multiple platforms

		ssize_t length = getxattr(file.c_str(), convertor.to_bytes(attributeName).c_str(), nullptr, 0);

		if (length > 0) {

			std::vector<char> buffer(length + 1);

			return convertor.from_bytes(buffer.data());

		} else {

			return L"";

		}

	}

public:

	void process(std::istream& input, std::ostream& output) {

		std::shared_ptr<RelationalWriter> writer(Factory::create(output));

		// TODO: redesign: parametrized from CLI + groups of information fetched together and used for multiple attributes

		bool enableName = true;

		bool enableExists = false;

		bool enableNameAbsolute = false;

		bool enableNameCanonical = false;

		bool enableType = true;

		bool enableSize = true;

		bool enableOwner = true;

		bool enableGroup = true;

		bool enableXattrUrl = true; // just a demo

		std::vector<AttributeMetadata> attributesMetadata;

		if (enableName) attributesMetadata.push_back({L"name", TypeId::STRING});

		if (enableExists) attributesMetadata.push_back({L"exists", TypeId::BOOLEAN});

		if (enableNameAbsolute) attributesMetadata.push_back({L"name_absolute", TypeId::STRING});

		if (enableNameCanonical) attributesMetadata.push_back({L"name_canonical", TypeId::STRING});

		if (enableType) attributesMetadata.push_back({L"type", TypeId::STRING});

		if (enableSize) attributesMetadata.push_back({L"size", TypeId::INTEGER});

		if (enableOwner) attributesMetadata.push_back({L"owner", TypeId::STRING});

		if (enableGroup) attributesMetadata.push_back({L"group", TypeId::STRING});

		if (enableXattrUrl) attributesMetadata.push_back({L"xattr_url", TypeId::STRING});

		writer->startRelation(L"filesystem", attributesMetadata, true);

		for (std::stringstream originalName; readNext(input, originalName); reset(originalName)) {

			if (enableName) writer->writeAttribute(convertor.from_bytes(originalName.str()));

			fs::path file(originalName.str());

			bool exists = false;

			try {

				exists = fs::exists(file);

			} catch (const fs::filesystem_error& e) {

				// we probably do not have permissions to given directory → pretend that the file does not exist

			}

			if (exists) {

				if (enableExists) writer->writeAttribute(L"true");

				if (enableNameAbsolute) writer->writeAttribute(fs::absolute(file).wstring());

				if (enableNameCanonical) writer->writeAttribute(fs::canonical(file).wstring());

				if (enableType) writer->writeAttribute(getType(file));

				if (enableSize) {

					integer_t size = fs::is_regular_file(file) ? fs::file_size(file) : 0;

					writer->writeAttribute(&size, typeid (size));

				}

				if (enableOwner || enableGroup) {

					string_t owner;

					string_t group;

					fetchOwner(file, owner, group);

					if (enableOwner) writer->writeAttribute(owner);

					if (enableGroup) writer->writeAttribute(group);

				}

				if (enableXattrUrl) writer->writeAttribute(getXattr(file, L"user.xdg.origin.url"));

			} else {

				// Only original name was written → write remaining attributes

				// TODO: null values (requires adding null support to the format specification)

				for (int i = 1; i < attributesMetadata.size(); i++) {

					switch (attributesMetadata[i].typeId) {

						case TypeId::BOOLEAN: writer->writeAttribute(L"false");

							break;

						case TypeId::INTEGER: writer->writeAttribute(L"0");

							break;

						case TypeId::STRING: writer->writeAttribute(L"");

							break;

						default:

							throw RelpipeWriterException(L"Unsupported data type.");

					}

				}

			}

		}

	}

};

}

}

}