#include "PgDatabaseCatalog.h"

#include "PgAttributeContainer.h"
#include "PgAuthIdContainer.h"
#include "PgClassContainer.h"
#include "PgDatabaseContainer.h"
#include "PgNamespaceContainer.h"
#include "PgTypeContainer.h"
#include "Pgsql_Connection.h"


QString getRoleNameFromOid(const PgDatabaseCatalog &cat, Oid oid)
{
	QString name;
	auto auth_ids = cat.authIds();
	if (auth_ids) {
		const PgAuthId& auth_id = auth_ids->getByKey(oid);
		if (auth_id.valid()) {
			name = auth_id.name;
		}
	}
	return name;
}

QString getRoleDisplayString(const PgDatabaseCatalog &cat, Oid oid)
{
	QString name = getRoleNameFromOid(cat, oid);
	return name;
//	return QString("%1 (%2)").arg(name).arg(oid);
}

QString getNamespaceDisplayString(const PgDatabaseCatalog &cat, Oid oid)
{
	//QString name;
	auto nss = cat.namespaces();
	auto ns = nss->getByKey(oid);
//	if (auth_ids) {
//		const PgAuthId& auth_id = auth_ids->getByOid(oid);
//		if (auth_id.valid()) {
//			name = auth_id.name;
//		}
//	}
	//return name;
	// TODO load list and lookup name
	return ns.name; //QString("ns %1").arg(oid);

}

QString getTablespaceDisplayString(const PgDatabaseCatalog &cat, Oid oid)
{
	// TODO load list and lookup name
	return QString("ts %1").arg(oid);
}

QString getTypeDisplayString(const PgDatabaseCatalog &cat, Oid oid)
{
	auto tc = cat.types();
	auto t = tc->getByKey(oid);
	return t.name;
}


PgDatabaseCatalog::PgDatabaseCatalog()
{
}

PgDatabaseCatalog::~PgDatabaseCatalog()
{
}

void PgDatabaseCatalog::loadAll(Pgsql::Connection &conn)
{
	loadInfo(conn);

	loadAttributes(conn);
	loadAuthIds(conn);
	loadClasses(conn);
	loadDatabases(conn);
	loadNamespaces(conn);
	loadTypes(conn);
}

void PgDatabaseCatalog::loadInfo(Pgsql::Connection &conn)
{
	Pgsql::Result r = conn.query("SHOW server_version_num");
	if (r && r.resultStatus() == PGRES_TUPLES_OK)
		if (r.rows() == 1)
			m_serverVersion << r.get(0, 0);

	r = conn.query("SELECT version()");
	if (r && r.resultStatus() == PGRES_TUPLES_OK)
		if (r.rows() == 1)
			m_serverVersionString = r.get(0, 0).asQString();
}

void load(Pgsql::Connection &conn, IPgContainter &pg_cont)
{
	std::string q = pg_cont.getLoadQuery();
	Pgsql::Result result = conn.query(q.c_str());
	if (result && result.resultStatus() == PGRES_TUPLES_OK)
		pg_cont.load(result);
	else
		throw std::runtime_error("Query failed");

}

void PgDatabaseCatalog::loadAttributes(Pgsql::Connection &conn)
{
	if (!m_attributes)
		m_attributes = std::make_shared<PgAttributeContainer>(shared_from_this());

	load(conn, *m_attributes);
}

void PgDatabaseCatalog::loadAuthIds(Pgsql::Connection &conn)
{
	if (!m_authIds)
		m_authIds = std::make_shared<PgAuthIdContainer>(shared_from_this());

	load(conn, *m_authIds);
}

void PgDatabaseCatalog::loadClasses(Pgsql::Connection &conn)
{
	if (!m_classes)
		m_classes = std::make_shared<PgClassContainer>(shared_from_this());

	load(conn, *m_classes);
}

void PgDatabaseCatalog::loadDatabases(Pgsql::Connection &conn)
{
	if (!m_databases)
		m_databases = std::make_shared<PgDatabaseContainer>(shared_from_this());

	load(conn, *m_databases);
}

void PgDatabaseCatalog::loadNamespaces(Pgsql::Connection &conn)
{
	if (!m_namespaces)
		m_namespaces = std::make_shared<PgNamespaceContainer>(shared_from_this());

	load(conn, *m_namespaces);
}

void PgDatabaseCatalog::loadTypes(Pgsql::Connection &conn)
{
	if (!m_types)
		m_types = std::make_shared<PgTypeContainer>(shared_from_this());

	load(conn, *m_types);
}


const QString& PgDatabaseCatalog::serverVersionString() const
{
	return m_serverVersionString;
}

int PgDatabaseCatalog::serverVersion() const
{
	return m_serverVersion;
}

std::shared_ptr<const PgAttributeContainer> PgDatabaseCatalog::attributes() const
{
	return m_attributes;
}

std::shared_ptr<const PgAuthIdContainer> PgDatabaseCatalog::authIds() const
{
	return m_authIds;
}

std::shared_ptr<const PgClassContainer> PgDatabaseCatalog::classes() const
{
	return m_classes;
}

std::shared_ptr<const PgDatabaseContainer> PgDatabaseCatalog::databases() const
{
	return m_databases;
}

std::shared_ptr<const PgNamespaceContainer> PgDatabaseCatalog::namespaces() const
{
	return m_namespaces;
}

std::shared_ptr<const PgTypeContainer> PgDatabaseCatalog::types() const
{
	return m_types;
}