#include "cdutils_k.h"
#include "cdutils_core.h"
#include "piconfig.h"
#include "pifile.h"

using namespace CDUtils;

KInterface K;


KInterface::KInterface() {
	core = CDCore::instance();
	//piCoutObj << (void*)this << core;
	k_file = PIStringAscii("k.dat");
	k_file_size = 0;
	CONNECTU(core, K_Sended, this, sended);
	CONNECTU(core, K_SendFail, this, sendFailed);
	CONNECTU(core, K_Received, this, received);
	CONNECTU(core, K_ReceiveFail, this, receiveFailed);
}


bool KInterface::test(int v) {
	return core->k_.test(v);
}


CDType & KInterface::operator [](const PIString & name_) {
	return core->k_[name_];
}


const CDType KInterface::operator [](const PIString & name_) const {
	return core->k_[name_];
}


CDType & KInterface::operator [](const PIDeque<int> & path_) {
	return core->k_[path_];
}


const CDType KInterface::operator [](const PIDeque<int> & path_) const {
	return core->k_[path_];
}


CDType & KInterface::operator [](int v) {
	//piCout << (void*)this << "[]" << core;
	return core->k_[v];
}


const CDType KInterface::operator [](int v) const {
	//piCout << (void*)this << "[]" << core;
	return core->k_[v];
}


CDSection & KInterface::section(int v) {
//	CDSection & ret = core->k_.section(v);
//	piCout << "[get section]" << v << ret.name;
	return core->k_.section(v);
}

const CDSection KInterface::section(int v) const {
	return core->k_.section(v);
}


CDSection & KInterface::section(const PIDeque<int> &path) {
	PIDeque<int> spath = path;
	CDSection * rs = &core->k_;
	while (!spath.isEmpty()) {
		rs = &rs->section(spath.take_front());
	}
	return *rs;
}


CDSection & KInterface::root() {
	return core->k_;
}


const CDSection KInterface::root() const {
	return core->k_;
}


int KInterface::count(bool recursive) const {
	return core->k_.count(recursive);
}


void KInterface::send() {
	core->K_Send();
}

void KInterface::request() {
	core->K_Request();
}


bool KInterface::configure(const PIString & config, const PIString & sect) {
	PIConfig conf(config, PIIODevice::ReadOnly);
	PIConfig::Entry & e(conf.getValue(sect));
	bool ret = false;
	k_file = e.getValue("file", "k.dat", &ret);
	return ret;
}


void KInterface::reinitConnection(const PIString &configuration) {
	core->init(configuration);
}


void KInterface::startPing() {
	core->startPing();
}


void KInterface::write(PIIODevice * d) {
	core->k_write(d);
}


void KInterface::read(PIIODevice * d) {
	core->k_read(d);
}


void KInterface::parse(PIIODevice * d) {
	core->k_parse(d);
}


void KInterface::update(PIIODevice * d, UpdateModeFlags mode) {
	core->k_update(d, mode);
}


void KInterface::calculate() {
	core->k_calculate();
}


PIString KInterface::appConfig() {
	return core->appConfig();
}


PIString KInterface::pultConfig() {
	return core->pultConfig();
}


void KInterface::readFile() {
	if (k_file.isEmpty()) return;
	PIFile f(k_file, PIIODevice::ReadOnly);
	read(&f);
	k_file_size = f.size();
}


void KInterface::writeFile() {
	if (k_file.isEmpty()) return;
	PIFile f(k_file, PIIODevice::ReadWrite);
	f.clear();
	write(&f);
	k_file_size = f.size();
}


bool KInterface::inProgress() {
	return core->inProgress();
}
