/*
# Copyright (C) 2015 Fulvio Benini

* This file is part of Scid (Shane's Chess Information Database).
*
* Scid 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.
*
* Scid 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 Scid. If not, see <http://www.gnu.org/licenses/>.
*/

#include "common.h"
#include "dbasepool.h"
#include "misc.h"
#include "scidbase.h"
#include "searchtournaments.h"
#include "ui.h"
#include <cstring>
#include <string>

namespace {
/*
* This "sc_base" functions are used by the UI to access the databases.
* To encapsulate database internal complexity this functions should only
* parse arguments and call other functions/objects.
*
* Command names are case sensitive
* Optional parameter are indicated using [value_opt]
* Alternative values are indicated using <value_a|value_b|value_c>
* BaseId is the handle used to select the database to work on
* "dbfilter" is the name of the default filter of database
* Games are numbered starting from "1"
* Example:
*     sc_base open "filename" -> on success returns a baseId handle to the opened database
*     sc_base gameslist baseId "1" "10" "dbfilter" "N+"
*     -> returns the list of the first 10 games of the database
*/


/**
 * doOpenBase() - open/create a database
 * @filename:    the filename of the database to open/create
 * @fMode:       open the database read-only|read-write|create|in_memory
 * @codec:       the type of the database
 *
 * If @fMode == FMODE_Both, and the file cannot be opened for writing, this
 * function will try to open the database read-only.
 */
static UI_res_t doOpenBase(UI_handle_t ti, const char* filename,
                           fileModeT fMode, ICodecDatabase::Codec codec) {
	if (DBasePool::find(filename) != 0) return UI_Result(ti, ERROR_FileInUse);

	scidBaseT* dbase = DBasePool::getFreeSlot();
	if (dbase == 0) return UI_Result(ti, ERROR_Full);

	Progress progress = UI_CreateProgress(ti);
	errorT err = dbase->Open(codec, fMode, filename, progress);

	if ((err == ERROR_FileOpen || err == ERROR_FileMode) &&
	    fMode == FMODE_Both) {
		err = dbase->Open(codec, FMODE_ReadOnly, filename, progress);
	}
	progress.report(1,1);

	if (err != OK && err != ERROR_NameDataLoss) return UI_Result(ti, err);

	int res = DBasePool::switchCurrent(dbase);
	return UI_Result(ti, err, res);
}


/**
 * sc_base_close() - close a database
 */
UI_res_t sc_base_close(scidBaseT* dbase, UI_handle_t ti, int, const char**) {
	if (dbase->getFileName() == "<clipbase>") {
		return UI_Result(ti, ERROR_BadArg, "Cannot close clipbase.");
	}
	return UI_Result(ti, dbase->Close());
}


/**
 * sc_base_compact() - compact a database
 * @stats: if used do not compact the database but calculate stats
 *
 * Compacting a database:
 * - remove all the games marked as "deleted"
 * - remove unused names
 * - makes search operations faster
 * - replace bad names with "???"
 */
UI_res_t sc_base_compact(scidBaseT* dbase, UI_handle_t ti, int argc,
                         const char** argv) {
	const char* usage = "Usage: sc_base compact baseId [stats]";

	if (argc == 3) {
		errorT res = dbase->compact(UI_CreateProgress(ti));
		return UI_Result(ti, res);
	} else if (argc == 4 && std::strcmp("stats", argv[3]) == 0) {
		unsigned long long n_deleted, n_unused, n_sparse, n_badNameId;
		errorT res = dbase->getCompactStat(&n_deleted, &n_unused, &n_sparse,
		                                   &n_badNameId);
		UI_List val(4);
		val.push_back(n_deleted);
		val.push_back(n_unused);
		val.push_back(n_sparse);
		val.push_back(n_badNameId);
		return UI_Result(ti, res, val);
	}

	return UI_Result(ti, ERROR_BadArg, usage);
}


/**
 * sc_base_copygames() - copy games from a database to another
 */
UI_res_t sc_base_copygames(scidBaseT* dbase, UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base copygames baseId <gameNum|filterName> targetBaseId";
	if (argc != 5) return UI_Result(ti, ERROR_BadArg, usage);

	scidBaseT* targetBase = DBasePool::getBase(strGetUnsigned(argv[4]));
	if (targetBase == 0)
		return UI_Result(ti, ERROR_BadArg, "sc_base copygames error: wrong targetBaseId");
	if (targetBase->isReadOnly())
		return UI_Result(ti, ERROR_FileReadOnly);

	errorT err = OK;
	const HFilter filter = dbase->getFilter(argv[3]);
	if (filter != 0) {
		err = targetBase->importGames(dbase, filter, UI_CreateProgress(ti));
	} else {
		uint gNum = strGetUnsigned (argv[3]);
		if (gNum == 0)
			return UI_Result(ti, ERROR_BadArg, "sc_base copygames error: wrong <gameNum|filterName>");
		err = targetBase->importGame(dbase, gNum -1);
	}
	return UI_Result(ti, err);
}


/**
 * sc_base_create() - crate a database
 * @codec : the type of the database
 * @filename: the filename of the wanted database.
 *            Database in native Scid format do not use extension ("example").
 *            Other databases require file extension ("example.pgn").
 *
 * Return:
 * - on success the handle assigned to the database
 */
UI_res_t sc_base_create(UI_handle_t ti, int argc, const char** argv) {
	const char* usage = "Usage: sc_base create <MEMORY|SCID4|PGN> filename";
	if (argc != 4 && argc != 3) return UI_Result(ti, ERROR_BadArg, usage);

	// Old interface defaults to SCID4
	ICodecDatabase::Codec codec = ICodecDatabase::SCID4;
	if (argc == 4) {
		if (std::strcmp("MEMORY", argv[2]) == 0)
			codec = ICodecDatabase::MEMORY;
		else if (std::strcmp("SCID4", argv[2]) == 0)
			codec = ICodecDatabase::SCID4;
		else if (std::strcmp("PGN", argv[2]) == 0)
			codec = ICodecDatabase::PGN;
		else
			return UI_Result(ti, ERROR_BadArg, usage);
	}

	return doOpenBase(
	    ti, argc == 4 ? argv[3] : argv[2],
	    codec == ICodecDatabase::MEMORY ? FMODE_Memory : FMODE_Create, codec);
}


/**
 * sc_base_extra() - get/set a database extra tag (i.e. "description" or "type")
 */
UI_res_t sc_base_extra(scidBaseT* dbase, UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base extra baseId [tagname new_value]";

	if (argc == 3) {
		auto list = dbase->getExtraInfo();
		UI_List res(list.size() * 2);
		for (const auto& e : list) {
			res.push_back(e.first);
			res.push_back(e.second.c_str());
		}
		return UI_Result(ti, OK, res);
	}
	if (argc == 5) {
		return UI_Result(ti, dbase->setExtraInfo(argv[3], argv[4]));
	}

	return UI_Result(ti, ERROR_BadArg, usage);
}


/**
 * sc_base_filename() - get the filename of a database
 *
 * Return:
 *   the full path filename for non native databases (like pgn)
 *   the full path filename without the .si4 extension for native Scid databases
 *   <clipbase> for the clipbase
 */
UI_res_t sc_base_filename(scidBaseT* dbase, UI_handle_t ti, int argc,
                          const char**) {
	const char* usage = "Usage: sc_base filename baseId";
	if (argc != 3) return UI_Result(ti, ERROR_BadArg, usage);

	return UI_Result(ti, OK, dbase->getFileName());
}


/**
 * sc_base_gameflag() - get/set a game flag (i.e. "D" for deleted)
 *
 * Return: a boolean value if the requested operation is "get"
 */
UI_res_t sc_base_gameflag(scidBaseT* dbase, UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base gameflag baseId <gameNum|filterName|all> <get|set|unset|invert> flagType";
	if (argc != 6) return UI_Result(ti, ERROR_BadArg, usage);

	int cmd = 0;
	if (std::strcmp("get", argv[4]) == 0)
		cmd = 1;
	else if (std::strcmp("set", argv[4]) == 0)
		cmd = 2;
	else if (std::strcmp("unset", argv[4]) == 0)
		cmd = 3;
	else if (std::strcmp("invert", argv[4]) == 0)
		cmd = 4;
	uint flagType = IndexEntry::CharToFlagMask(argv[5][0]);
	if (flagType != 0 && cmd != 0) {
		bool value = (cmd == 2);

		const HFilter filter = dbase->getFilter(argv[3]);
		if (filter != 0 || (std::strcmp("all", argv[3]) == 0)) {
			switch (cmd) {
			case 2:
			case 3: return UI_Result(ti, dbase->setFlag(value, flagType, filter));
			case 4: return UI_Result(ti, dbase->invertFlag(flagType, filter));
			}
		} else {
			gamenumT gNum = strGetUnsigned(argv[3]);
			if (gNum > 0 && gNum <= dbase->numGames()) {
				gNum--;
				switch (cmd) {
				case 1: return UI_Result(ti, OK, dbase->getFlag(flagType, gNum));
				case 2:
				case 3: return UI_Result(ti, dbase->setFlag(value, flagType, gNum));
				case 4: return UI_Result(ti, dbase->invertFlag(flagType, gNum));
				}
			}
		}
	}

	return UI_Result(ti, ERROR_BadArg, usage);
}


/**
 * sc_base_gamelocation() - find the position of a game
 * @sortCrit:      the order for the list of games to search
 * @gnumber:       the number of the game to search for
 * @text:          if (@gnumber == 0) search the first game that contains @text in
 *                 white name or black name or event name or site name
 * @start_pos:     used only with @text, start searching from a zero-based position.
 * @forward_dir:   <true|false>, used only with @start_pos.
 *                 if @e true search in the range [start_pos, numGames)
 *                 if @e false search in the range [0, start_pos)
 *
 * Return: the position (0 == first) of the first match or "none" if not found
 */
UI_res_t sc_base_gamelocation(scidBaseT* dbase, UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base gamelocation baseId filterName sortCrit <gnumber | 0 text start_pos forward_dir>";
	if (argc < 6) return UI_Result(ti, ERROR_BadArg, usage);

	const HFilter filter = dbase->getFilter(argv[3]);
	if (filter == 0) return UI_Result(ti, ERROR_BadArg, usage);

	const char* sort = argv[4];
	gamenumT gnumber = strGetUnsigned(argv[5]);
	size_t location = INVALID_GAMEID;
	if (gnumber == 0) {
		if (argc != 9)
			return UI_Result(ti, ERROR_BadArg, usage);
		const char* text = argv[6];
		size_t start = strGetUnsigned(argv[7]);
		const NameBase* nb = dbase->getNameBase();
		auto contains = [dbase, nb, text](gamenumT g) {
			const IndexEntry* ie = dbase->getIndexEntry(g);
			return strAlphaContains(ie->GetWhiteName(nb), text) ||
			       strAlphaContains(ie->GetBlackName(nb), text) ||
			       strAlphaContains(ie->GetEventName(nb), text) ||
			       strAlphaContains(ie->GetSiteName(nb), text);
		};
		if (strGetBoolean(argv[8])) {
			std::vector<gamenumT> buf(filter->size() - start);
			buf.resize(
			    dbase->listGames(sort, start, buf.size(), filter, buf.data()));
			auto it = std::find_if(buf.begin(), buf.end(), contains);
			if (it != buf.end())
				location = start + std::distance(buf.begin(), it);
		} else {
			std::vector<gamenumT> buf(start);
			buf.resize(dbase->listGames(sort, 0, start, filter, buf.data()));
			auto it = std::find_if(buf.rbegin(), buf.rend(), contains);
			if (it != buf.rend())
				location = std::distance(it, buf.rend()) - 1;
		}
	} else {
		location = dbase->sortedPosition(sort, filter, gnumber - 1);
	}
	if (location == INVALID_GAMEID)
		return UI_Result(ti, OK, "none"); // Not found
	return UI_Result(ti, OK, location);
}


/**
 * sc_base_gameslist() - returns the sorted list of games of a database
 * @start:    0 for the first game
 */
UI_res_t sc_base_gameslist(scidBaseT* dbase, UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base gameslist baseId start count filterName sortCrit";
	if (argc != 7) return UI_Result(ti, ERROR_BadArg, usage);

	size_t start = strGetUnsigned(argv[3]);
	size_t count = strGetUnsigned(argv[4]);
	const HFilter filter = dbase->getFilter(argv[5]);
	if (filter == NULL)
		return UI_Result(ti, ERROR_BadArg, usage);
	gamenumT* idxList = new gamenumT[count];
	count = dbase->listGames(argv[6], start, count, filter, idxList);

	UI_List res (count * 3);
	UI_List ginfo(24);
	const NameBase* nb = dbase->getNameBase();
	for (uint i = 0; i < count; ++i) {
		uint idx = idxList[i];

		ASSERT(filter->get(idx) != 0);
		uint ply = filter->get(idx) -1;

		const IndexEntry* ie = dbase->getIndexEntry(idx);

		ginfo.clear();
		ginfo.push_back(idx +1);
		ginfo.push_back(RESULT_STR[ie->GetResult()]);
		ginfo.push_back((ie->GetNumHalfMoves() + 1) / 2);
		ginfo.push_back(ie->GetWhiteName(nb));
		std::string eloStr;
		eloT welo = ie->GetWhiteElo();
		if (welo != 0) {
			eloStr = std::to_string(welo);
		} else {
			welo = ie->GetWhiteElo(nb);
			eloStr = std::to_string(welo);
			if (welo != 0) {
				eloStr.insert(eloStr.begin(), '(');
				eloStr.insert(eloStr.end(), ')');
			}
		}
		ginfo.push_back(eloStr);
		ginfo.push_back(ie->GetBlackName(nb));
		eloT belo = ie->GetBlackElo();
		if (belo != 0) {
			eloStr = std::to_string(belo);
		} else {
			belo = ie->GetBlackElo(nb);
			eloStr = std::to_string(belo);
			if (belo != 0) {
				eloStr.insert(eloStr.begin(), '(');
				eloStr.insert(eloStr.end(), ')');
			}
		}
		ginfo.push_back(eloStr);
		char buf_date[16];
		date_DecodeToString (ie->GetDate(), buf_date);
		ginfo.push_back(buf_date);
		ginfo.push_back(ie->GetEventName(nb));
		ginfo.push_back(ie->GetRoundName(nb));
		ginfo.push_back(ie->GetSiteName(nb));
		ginfo.push_back(ie->GetNagCount());
		ginfo.push_back(ie->GetCommentCount());
		ginfo.push_back(ie->GetVariationCount());
		char deleted[2] = {0};
		deleted[0] = (ie->GetDeleteFlag()) ? 'D' : ' ';
		ginfo.push_back(deleted);
		char flags[16];
		ie->GetFlagStr (flags, "WBMENPTKQ!?U123456");
		ginfo.push_back(flags);
		ecoStringT ecoStr;
		eco_ToExtendedString (ie->GetEcoCode(), ecoStr);
		ginfo.push_back(ecoStr);
		std::string endMaterial = matsig_makeString(ie->GetFinalMatSig());
		ginfo.push_back(endMaterial);
		char startpos[2] = {0};
		startpos[0] = (ie->GetStartFlag()) ? 'S' : ' ';
		ginfo.push_back(startpos);
		char buf_eventdate[16];
		date_DecodeToString (ie->GetEventDate(), buf_eventdate);
		ginfo.push_back(buf_eventdate);
		ginfo.push_back(ie->GetYear());
		ginfo.push_back((welo + belo)/2);
		ginfo.push_back(ie->GetRating(nb));
		FastGame game = dbase->getGame(ie);
		ginfo.push_back(game.getMoveSAN(ply, 10));

		res.push_back(std::to_string(idx+1) + "_" + std::to_string(ply));
		res.push_back(ginfo);
		res.push_back(deleted);
	}

	delete [] idxList;
	return UI_Result(ti, OK, res);
}

static UI_res_t sc_base_getGameHelper(UI_handle_t ti, Game& game) {
	auto positions = gamepos::collectPositions(game);
	UI_List res(positions.size());
	UI_List posInfo(6);
	for (const auto& pos : positions) {
		posInfo.clear();
		posInfo.push_back(pos.RAVdepth);
		posInfo.push_back(pos.RAVnum);
		posInfo.push_back(pos.FEN);
		std::string nags;
		for (const auto& nag : pos.NAGs) {
			char temp[16];
			game_printNag(nag, temp, true, PGN_FORMAT_Plain);
			if (!nags.empty())
				nags += ' ';
			nags += temp;
		}
		posInfo.push_back(nags);
		posInfo.push_back(pos.comment);
		posInfo.push_back(pos.lastMoveSAN);
		res.push_back(posInfo);
	}
	return UI_Result(ti, OK, res);
}

/**
 * sc_base_getGame() - return all the positions of a game
 * @param gameNum: the number of the requested game
 * @param live: optional parameter which specify the behavior when the requested
 * game have unsaved changes. If present the latest unsaved version is returned,
 * otherwise the saved copy in the database is used.
 *
 * Return a list containing all the positions of a game, including variations.
 * The positions are sorted according to pgn standard:
 * "The alternate move sequence given by an RAV is one that may be legally
 * played by first unplaying the move that appears immediately prior to the
 * RAV". For each position the following informations are provided: RAVdepth:
 * current variation depth. RAVnum: current variation num. FEN: "Forsyth-Edwards
 * Notation" describing the current position. NAGS: "Numeric Annotation Glyph"
 * is a non-negative integer from 0 to 255 used to indicate a simple annotation
 * in a language independent manner. comment: text annotation of the
 * current position. lastMoveSAN: the last move that was played to reach the
 * current position. The move is indicated using English "Standard Algebraic
 * Notation".
 */
UI_res_t sc_base_getGame(scidBaseT* dbase, UI_handle_t ti, int argc,
                         const char** argv) {
	const char* usage = "Usage: sc_base getGame baseId gameNum [live]";
	bool live = (argc == 5 && std::strcmp("live", argv[4]) == 0);
	if (!live && argc != 4)
		return UI_Result(ti, ERROR_BadArg, usage);

	gamenumT gNum = strGetUnsigned(argv[3]);
	if (live && dbase->gameNumber == (static_cast<long long>(gNum) - 1)) {
		auto location = dbase->game->currentLocation();
		auto res = sc_base_getGameHelper(ti, *(dbase->game));
		dbase->game->restoreLocation(location);
		return res;
	}

	auto ie = (gNum > 0) ? dbase->getIndexEntry_bounds(gNum - 1) : nullptr;
	if (!ie)
		return UI_Result(ti, ERROR_BadArg, usage);

	Game game;
	errorT err = dbase->getGame(*ie, game);
	if (err != OK)
		return UI_Result(ti, err);
	return sc_base_getGameHelper(ti, game);
}

/**
 * sc_base_import() - import games from non-native database
 *
 * Return:
 *   On success, returns a list of two elements: the number of
 *   games imported and a string containing import errors
 *   or warnings.
 */
UI_res_t sc_base_import(scidBaseT* dbase, UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base import baseId filename";
	if (argc != 4) return UI_Result(ti, ERROR_BadArg, usage);

	// if (pgn)
	auto codec = ICodecDatabase::PGN;

	auto nImported = dbase->numGames();
	std::string errorMsg;
	auto res_imp =
	    dbase->importGames(codec, argv[3], UI_CreateProgress(ti), errorMsg);
	if (res_imp != OK)
		return UI_Result(ti, res_imp);

	UI_List res(2);
	res.push_back(dbase->numGames() - nImported);
	res.push_back(errorMsg);
	return UI_Result(ti, OK, res);
}


/**
 * sc_base_list() - return a baseId list of opened databases
 */
UI_res_t sc_base_list(UI_handle_t ti, int argc, const char**) {
	const char* usage = "Usage: sc_base list";
	if (argc != 2) return UI_Result(ti, ERROR_BadArg, usage);

	std::vector<int> l = DBasePool::getHandles();
	UI_List res(l.size());
	for (size_t i=0, n=l.size(); i < n; i++) res.push_back(l[i]);
	return UI_Result(ti, OK, res);
}


/**
 * sc_base_numGames() - return the number of games in the database
 */
UI_res_t sc_base_numGames(scidBaseT* dbase, UI_handle_t ti, int argc,
                          const char**) {
	const char* usage = "Usage: sc_base numGames baseId";
	if (argc != 3) return UI_Result(ti, ERROR_BadArg, usage);

	return UI_Result(ti, OK, dbase->numGames());
}


/**
 * sc_base_open() - open a database
 * @codec : the type of the database
 * @filename: the filename of the wanted database.
 *            Database in native Scid format do not use extension ("example").
 *            Other databases require file extension ("example.pgn").
 *
 * Return:
 * - on success or with ERROR_NameDataLoss: the handle assigned to the database
 */
UI_res_t sc_base_open(UI_handle_t ti, int argc, const char** argv) {
	const char* usage = "Usage: sc_base open <SCID4|PGN> filename";
	if (argc != 4 && argc != 3) return UI_Result(ti, ERROR_BadArg, usage);

	// Old interface defaults to SCID4
	ICodecDatabase::Codec codec = ICodecDatabase::SCID4;
	if (argc == 4) {
		if (std::strcmp("SCID4", argv[2]) == 0)
			codec = ICodecDatabase::SCID4;
		else if (std::strcmp("PGN", argv[2]) == 0)
			codec = ICodecDatabase::PGN;
		else
			return UI_Result(ti, ERROR_BadArg, usage);
	}

	return doOpenBase(ti, argc == 4 ? argv[3] : argv[2], FMODE_Both, codec);
}


/**
 * sc_base_slot() - get the handle of an opened database
 * @filename: the filename of the wanted database.
 *            Database in native Scid format do not use extension ("example").
 *            Other databases require file extension ("example.pgn").
 *
 * Return:
 * - the handle of the database corresponding to @filename.
 * - 0 if not found.
 */
UI_res_t sc_base_slot(UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base slot filename";
	if (argc != 3) return UI_Result(ti, ERROR_BadArg, usage);

	int res = DBasePool::find(argv[2]);
	return UI_Result(ti, OK, res);
}


/**
 * sc_base_sortcache() - create/release a sortcache
 *
 * A sortchace is used to speed up the other sc_base functions with the same "sortCrit"
 */
UI_res_t sc_base_sortcache(scidBaseT* dbase, UI_handle_t ti, int argc, const char** argv)
{
	const char* usage = "Usage: sc_base sortcache baseId <create|release> sortCrit";
	if (argc != 5) return UI_Result(ti, ERROR_BadArg, usage);

	if (std::strcmp("create", argv[3]) == 0) {
		if (dbase->createSortCache(argv[4]) == NULL)
			return UI_Result(ti, ERROR);
	} else {
		dbase->releaseSortCache(argv[4]);
	}
	return UI_Result(ti, OK);
}


/**
 * sc_base_stats() - return statistics about a database.
 *
 * The returned values are specific for every subcomand:
 * dates   -> {minimum year} {maximum year} {mean year}
 * eco ?   -> {number of games with for the ? eco} {white wins} {draws}
 *            {black wins} {n_games with empty result} {score in %}
 *            ? must be a valid ECO code or an abbreviation, for example:
 *            A returns the sum of all the A00,A00a...A99z4
 *            A1 returns the sum of all the A10,A10a,A10a1...A19z4
 *            A10 returns the sum of all the A10,A10a,A10a1...A10z4
 *            An empty string returns the sum of all valid ECO codes
 * flag ?  -> {number of games with the ? flag set}
 *            ? must be a valid flag char (see IndexEntry::CharToFlag())
 * flags   -> {n_games with D flag set} {n_games with W flag set} {n_games with B flag set}
 * ratings -> {minimum elo} {maximum elo {mean elo}
 * results -> {number of games won by white} {number of draws} {number of
 *             games won by black} {number of games with no result}
 */
UI_res_t sc_base_stats(const scidBaseT* dbase, UI_handle_t ti, int argc, const char ** argv)
{
	const char* usage = "Usage: sc_base stats baseId <dates|eco ?|flag ?|flags|ratings|results>";
	if (argc < 4) return UI_Result(ti, ERROR_BadArg, usage);

	const char* subcmd = argv[3];
	const scidBaseT::Stats& stats = dbase->getStats();
	UI_List res(6);

	enum { OPT_DATE, OPT_ECO, OPT_FLAG, OPT_FLAGS, OPT_RATINGS, OPT_RESULTS };
	const char * options[] = { "dates", "eco", "flag", "flags", "ratings", "results", NULL };
	switch (strExactMatch(subcmd, options)) {
	case OPT_DATE:
		res.push_back(date_GetYear(stats.minDate));
		res.push_back(date_GetYear(stats.maxDate));
		res.push_back(stats.nYears == 0 ? 0 : size_t(stats.sumYears / stats.nYears));
		break;
	case OPT_ECO: {
		const scidBaseT::Stats::Eco* eco = (argc != 5) ? 0 : stats.getEcoStats(argv[4]);
		if (eco == 0) return UI_Result(ti, ERROR_BadArg, usage);
		res.push_back(eco->count);
		res.push_back(eco->results[RESULT_White]);
		res.push_back(eco->results[RESULT_Draw]);
		res.push_back(eco->results[RESULT_Black]);
		res.push_back(eco->results[RESULT_None]);
		ASSERT(eco->count >= eco->results[RESULT_None]);
		uint count = eco->count - eco->results[RESULT_None];
		uint score = eco->results[RESULT_White] * 2;
		score += eco->results[RESULT_Draw];
		score *= 500;
		res.push_back(count == 0 ? 0.0 : score / count / 10.0);
		break; }
	case OPT_FLAG: {
		uint flag = (argc != 5) ? 0 : IndexEntry::CharToFlag(*(argv[4]));
		if (flag == 0) return UI_Result(ti, ERROR_BadArg, usage);
		res.push_back(stats.flagCount[flag]);
		break; }
	case OPT_FLAGS:
		res.push_back(stats.flagCount[IndexEntry::CharToFlag('D')]);
		res.push_back(stats.flagCount[IndexEntry::CharToFlag('W')]);
		res.push_back(stats.flagCount[IndexEntry::CharToFlag('B')]);
		break;
	case OPT_RATINGS:
		res.push_back(stats.minRating);
		res.push_back(stats.maxRating);
		res.push_back(stats.nRatings == 0 ? 0 : size_t(stats.sumRatings / stats.nRatings));
		break;
	case OPT_RESULTS:
		res.push_back(stats.nResults[RESULT_White]);
		res.push_back(stats.nResults[RESULT_Draw]);
		res.push_back(stats.nResults[RESULT_Black]);
		res.push_back(stats.nResults[RESULT_None]);
		break;
	default:
		return UI_Result(ti, ERROR_BadArg, usage);
	}

	return UI_Result(ti, OK, res);
}


/**
 * sc_base_switch() - change the current database and the current game
 *
 * DEPRECATED
 * Unfortunately Scid used to have only one database, one game, one filter, etc...
 * This function changes the current database and consequently the current game 
 * (sc_game functions works on the current game)
 *
 * Return: the current database ID after the switch
 */
UI_res_t sc_base_switch(scidBaseT* dbase, UI_handle_t ti)
{
	int res = DBasePool::switchCurrent(dbase);
	return UI_Result(ti, OK, res);
}


/**
 * sc_base_tournaments() - return a list of tournaments
 *
 * Games with the same [Event], [Site] and [EventDate] tags are considered
 * a tournament (also games with empty [EventDate] tag are included).
 * The list returned can be restricted based on the average elo of the
 * participants, the number of games, the number of players and the name
 * of a participant.
 * Ranges can be specified with one or two numbers separated by spaces (min max).
 * The returned list can be sorted according to the following criteria:
 * - "Date"    : date of the first games in the tournament
 * - "Players" : number of participants to the tournament
 * - "Games"   : number of games
 * - "Elo"     : average elo of the participants
 * - "Site"    : site name
 * - "Event"   : event name
 *
 * Return:
 *   On success, return a list of tournaments.
 *   For each tournament the following info are provided:
 *   date of the first games, site name, event name, number of players,
 *   number of games, average elo of the participants, lowest game number,
 *   winner name, winner elo, winner score, 2nd place name, 2nd elo, 2nd score.
 */
UI_res_t sc_base_tournaments(const scidBaseT* dbase, UI_handle_t ti, int argc, const char ** argv)
{
	const char* usage = "Usage: sc_base tournaments baseId filterName n_maxResults [-avgelo range] [-n_games range] [-n_players range] [-sort criteria] ";
	if (argc < 5) return UI_Result(ti, ERROR_BadArg, usage);

	const HFilter filter = dbase->getFilter(argv[3]);
	if (filter == 0) return UI_Result(ti, ERROR_BadArg, usage);

	SearchTournaments search(dbase, filter);

	const char* sortCriteria = 0;
	long nResults = strGetUnsigned(argv[4]);

	static const char* options[] = {
		"-avgelo", "-n_games", "-n_players", "-player", "-sort", NULL
	};
	enum { AVGELO, N_GAMES, N_PLAYERS, PLAYER, SORT };

	for (int i = 5; (i + 1) < argc; i += 2) {
		int index = strUniqueMatch(argv[i], options);
		const char* value = argv[i + 1];
		if (*value == 0) continue;
		switch (index) {
		case AVGELO:
			search.filterByAvgElo(StrRange(value));
			break;
		case N_GAMES:
			search.filterByNGames(StrRange(value));
			break;
		case N_PLAYERS:
			search.filterByNPlayers(StrRange(value));
			break;
		case PLAYER:
			search.filterByPlayer(value);
			break;
		case SORT:
			sortCriteria = value;
			break;
		default:
			return UI_Result(ti, ERROR_BadArg, usage);
		}
	}

	if (sortCriteria != 0) {
		if (!search.sort(sortCriteria, nResults))
			return UI_Result(ti, ERROR_BadArg, usage);
	}

	SearchTournaments::Iter it = search.begin();
	SearchTournaments::Iter it_end = search.end();
	if (std::distance(it, it_end) > nResults) {
		it_end = it + nResults;
	}

	char buf_date[16];
	const NameBase* nb = dbase->getNameBase();
	UI_List res(std::distance(it, it_end));
	UI_List tourney(14);
	for (; it != it_end; it++) {
		tourney.clear();
		date_DecodeToString(it->getStartDate(), buf_date);
		strTrimDate(buf_date);
		tourney.push_back(buf_date);
		tourney.push_back(nb->GetName(NAME_SITE, it->getSiteId()));
		tourney.push_back(nb->GetName(NAME_EVENT, it->getEventId()));
		tourney.push_back(it->nPlayers());
		tourney.push_back(it->nGames());
		tourney.push_back(it->getAvgElo());
		tourney.push_back(it->getStartGameNum() + 1);
		const char* name1st = "";
		eloT elo1st = 0;
		double score1st = 0.0;
		const char* name2nd = "";
		eloT elo2nd = 0;
		double score2nd = 0.0;
		if (it->nPlayers() > 0) {
			const Tourney::Player& p = it->getPlayer(0);
			name1st = nb->GetName(NAME_PLAYER, p.nameId);
			elo1st = p.elo;
			score1st = p.score / 2.0;
		}
		if (it->nPlayers() > 1) {
			const Tourney::Player& p = it->getPlayer(1);
			name2nd = nb->GetName(NAME_PLAYER, p.nameId);
			elo2nd = p.elo;
			score2nd = p.score / 2.0;
		}
		tourney.push_back(name1st);
		tourney.push_back(elo1st);
		tourney.push_back(score1st);
		tourney.push_back(name2nd);
		tourney.push_back(elo2nd);
		tourney.push_back(score2nd);

		res.push_back(tourney);
	}

	return UI_Result(ti, OK, res);
}

/**
 * sc_base_player_elo() - return a list of elo values of a player
 * Return:
 *   On success, return a list of years (the month is added in the fractional
 *   part: 2018.00 ==> gen 2018, 2018.75 ==> oct 2018, etc..) and elos.
 */
UI_res_t sc_base_player_elo(const scidBaseT& dbase, UI_handle_t ti, int argc,
                            const char** argv) {
	const char* usage = "Usage: sc_base player_elo baseId filterName playerName";
	if (argc != 5)
		return UI_Result(ti, ERROR_BadArg, usage);

	const HFilter filter = dbase.getFilter(argv[3]);
	if (filter == nullptr)
		return UI_Result(ti, ERROR_BadArg, usage);

	idNumberT id = 0;
	if (dbase.getNameBase()->FindExactName(NAME_PLAYER, argv[4], &id) != OK)
		return UI_Result(ti, OK);

	std::map<unsigned, eloT> eloByMonth;
	auto getPlayerElo = [](auto idx_entry, auto player_id) -> eloT {
		ASSERT(idx_entry);
		if (idx_entry->GetWhite() == player_id)
			return idx_entry->GetWhiteElo();
		if (idx_entry->GetBlack() == player_id)
			return idx_entry->GetBlackElo();
		return 0;
	};
	for (auto gnum : filter) {
		const IndexEntry* ie = dbase.getIndexEntry(gnum);
		if (auto elo = getPlayerElo(ie, id)) {
			auto date = ie->GetDate();
			auto year = date_GetYear(date);
			auto month = date_GetMonth(date);
			if (month > 0) {
				month--;
			}
			if (month > 11) {
				month = 0;
			}
			eloByMonth[year * 12 + month] = elo;
		}
	}

	UI_List res(eloByMonth.size() * 2);
	for (auto& e : eloByMonth) {
		res.push_back(e.first / 12.0); // year
		res.push_back(e.second);       // elo
	}
	return UI_Result(ti, OK, res);
}

} // End of anonymous namespace

//TODO: move this function here from tkscid.cpp
UI_res_t sc_base_inUse       (UI_extra_t, UI_handle_t, int argc, const char ** argv);
UI_res_t sc_base_export      (UI_extra_t, UI_handle_t, int argc, const char ** argv);
UI_res_t sc_base_piecetrack  (UI_extra_t, UI_handle_t, int argc, const char ** argv);
UI_res_t sc_base_tag         (UI_extra_t, UI_handle_t, int argc, const char ** argv);
uint sc_base_duplicates (scidBaseT* dbase, UI_handle_t, int argc, const char ** argv);


UI_res_t sc_base (UI_extra_t cd, UI_handle_t ti, int argc, const char ** argv)
{
	static const char * options [] = {
	    "close",           "compact",         "copygames",
	    "create",          "current",         "duplicates",
	    "export",          "extra",           "filename",        "gameflag",
	    "gamelocation",    "gameslist",       "getGame",         "import",
	    "inUse",           "isReadOnly",      "list",            "numGames",        "open",
	    "piecetrack",      "player_elo",      "slot",            "sortcache",       "stats",
	    "switch",          "tag",             "tournaments",     "type",
	    NULL
	};
	enum {
	    BASE_CLOSE,        BASE_COMPACT,      BASE_COPYGAMES,
	    BASE_CREATE,       BASE_CURRENT,      BASE_DUPLICATES,
	    BASE_EXPORT,       BASE_EXTRA,        BASE_FILENAME,     BASE_GAMEFLAG,
	    BASE_GAMELOCATION, BASE_GAMESLIST,    BASE_GETGAME,      BASE_IMPORT,
	    BASE_INUSE,        BASE_ISREADONLY,   BASE_LIST,         BASE_NUMGAMES,     BASE_OPEN,
	    BASE_PTRACK,       BASE_PLAYER_ELO,   BASE_SLOT,         BASE_SORTCACHE,    BASE_STATS,
	    BASE_SWITCH,       BASE_TAG,          BASE_TOURNAMENTS,  BASE_TYPE
	};

	if (argc <= 1) return UI_Result(ti, ERROR_BadArg, "Usage: sc_base <cmd>");

	int index = strUniqueMatch (argv[1], options);
	switch (index) {
	case BASE_CREATE:
		return sc_base_create(ti, argc, argv);

	case BASE_CURRENT:
		return sc_base_switch(0, ti);

	case BASE_EXPORT:
		return sc_base_export (cd, ti, argc, argv);

	case BASE_INUSE:
		return sc_base_inUse (cd, ti, argc, argv);

	case BASE_LIST:
		return sc_base_list(ti, argc, argv);

	case BASE_OPEN:
		return sc_base_open(ti, argc, argv);

	case BASE_PTRACK:
		return sc_base_piecetrack (cd, ti, argc, argv);

	case BASE_SLOT:
		return sc_base_slot (ti, argc, argv);

	case BASE_TAG:
		return sc_base_tag (cd, ti, argc, argv);
	}

	//New multi-base functions
	if (argc < 3) return UI_Result(ti, ERROR_BadArg, "Usage: sc_base <cmd> baseId [args]");
	scidBaseT* dbase = DBasePool::getBase(strGetUnsigned(argv[2]));
	if (dbase == 0) return UI_Result(ti, ERROR_FileNotOpen);

	switch (index) {
	case BASE_CLOSE:
		return sc_base_close(dbase, ti, argc, argv);

	case BASE_COMPACT:
		return sc_base_compact(dbase, ti, argc, argv);

	case BASE_COPYGAMES:
		return sc_base_copygames(dbase, ti, argc, argv);

	case BASE_DUPLICATES:
		if (dbase->isReadOnly()) return UI_Result(ti, ERROR_FileReadOnly);
		return UI_Result(ti, OK, sc_base_duplicates (dbase, ti, argc, argv));

	case BASE_EXTRA:
		return sc_base_extra(dbase, ti, argc, argv);

	case BASE_FILENAME:
		return sc_base_filename(dbase, ti, argc, argv);

	case BASE_GAMEFLAG:
		return sc_base_gameflag(dbase, ti, argc, argv);

	case BASE_GAMELOCATION:
		return sc_base_gamelocation(dbase, ti, argc, argv);

	case BASE_GAMESLIST:
		return sc_base_gameslist(dbase, ti, argc, argv);

	case BASE_GETGAME:
		return sc_base_getGame(dbase, ti, argc, argv);

	case BASE_IMPORT:
		return sc_base_import (dbase, ti, argc, argv);

	case BASE_ISREADONLY:
		return UI_Result(ti, OK, dbase->isReadOnly());

	case BASE_NUMGAMES:
		return sc_base_numGames (dbase, ti, argc, argv);

	case BASE_PLAYER_ELO:
		return sc_base_player_elo(*dbase, ti, argc, argv);

	case BASE_SORTCACHE:
		return sc_base_sortcache(dbase, ti, argc, argv);

	case BASE_STATS:
		return sc_base_stats(dbase, ti, argc, argv);

	case BASE_SWITCH:
		return sc_base_switch (dbase, ti);

	case BASE_TOURNAMENTS:
		return sc_base_tournaments (dbase, ti, argc, argv);
	}

	std::string res = "sc_base\nInvalid minor command: ";
	res.append(argv[1]);
	return UI_Result(ti, ERROR_BadArg, res);
}
