#pragma once

#include <cstdlib>

#include <iostream>

#include <string>

#include <vector>

#include <algorithm>

#include <string>

#include <locale>

#include <relpipe/writer/typedefs.h>

#include <relpipe/cli/CLI.h>

#include <relpipe/cli/RelpipeCLIException.h>

#include "Command.h"

namespace relpipe {

namespace in {

namespace cli {

/**

 * TODO: consider code merge with ArgumentsCommand

 */

class StdInCommand : public Command {

private:

	relpipe::writer::boolean_t readStdIn;

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

	/**

	 * Reads next value from arguments and (if no arguments left) from input

	 * @param input

	 * @param arguments

	 * @param i current index in the arguments vector

	 * @param required if true, exception is thrown when no data found

	 * @return 

	 */

	relpipe::writer::string_t readNext(std::istream& input, const std::vector<relpipe::writer::string_t>& arguments, size_t& i, relpipe::writer::boolean_t required) {

		using namespace relpipe::writer;

		using namespace relpipe::cli;

		if (i < arguments.size()) {

			return arguments[i++];

		} else if (readStdIn) {

			std::stringstream value;

			while (true) {

				char ch;

				input.get(ch);

				if (ch == 0 || input.eof() || input.fail()) break;

				else value << ch;

			}

			if (required && value.str().empty()) throw RelpipeCLIException(L"Missing value on STDIN.", CLI::EXIT_CODE_BAD_SYNTAX);

			return convertor.from_bytes(value.str());

		} else {

			if (required) throw RelpipeCLIException(L"Missing value on CLI.", CLI::EXIT_CODE_BAD_SYNTAX);

			return L"";

		}

	}

public:

	StdInCommand(relpipe::writer::boolean_t readStdIn) :

	readStdIn(readStdIn) {

	}

	void process(std::istream& input, std::ostream& output, const relpipe::writer::string_t& command, const std::vector<relpipe::writer::string_t>& arguments) override {

		using namespace relpipe::writer;

		size_t i = 0;

		string_t relationName = readNext(input, arguments, i, true);

		integer_t attributeCount = std::stoul(readNext(input, arguments, i, true)); // TODO: use integer data type's method?

		boolean_t writeHeader = true; // TODO: add option for header omitting

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

		std::vector<std::pair<string_t, TypeId >> attributes(attributeCount);

		for (size_t j = 0; j < attributeCount; j++) {

			string_t attributeName = readNext(input, arguments, i, true);

			TypeId attributeType = writer->toTypeId(readNext(input, arguments, i, true));

			attributes[j] = {attributeName, attributeType};

		}

		writer->startRelation(relationName, attributes, writeHeader);

		while (true) {

			string_t value = readNext(input, arguments, i, false);

			if (value.empty() && (input.eof() || input.fail() || (!readStdIn && i >= arguments.size()))) break;

			else writer->writeAttribute(value);

			// TODO: check attribute count (avoid unfinished records)

		}

	}

};

}

}

}