/*
 * Nomad Instrument Control Software
 *
 * Copyright 2011 Institut Laue-Langevin
 *
 * Licensed under the EUPL, Version 1.1 only (the "License");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at:
 *
 * http://joinup.ec.europa.eu/software/page/eupl
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing permissions and
 * limitations under the Licence.
 */

#include "DPPAcquisitionController.h"
#include "controllers/common/family/Families.h"
#include <lstdpp128/lstdpp.h>

using namespace std;
using namespace acquisition;
using namespace lstdpp128;

namespace npp {

const string DPPAcquisitionController::TYPE = "dppacquisition_setup";

const string DPPAcquisitionController::NO_LIVE_PROCESS = "none";
const string DPPAcquisitionController::HISTOGRAM_PROCESS = "histogram";
const string DPPAcquisitionController::COINCIDENCE_PROCESS = "coincidence";

/*
 * Constructor
 */
DPPAcquisitionController::DPPAcquisitionController(const string& name) :
		TimeAcquisitionController(name) {

	setFamily(family::ACQUISITION, family::SETTING);

	nbAdcControllers.init(this, SAVE, "nb_adc_controllers");
	nbBits.init(this, SAVE, "nb_bits");
	gateWidth.init(this, SAVE, "gate_width");
	scopeChannel.init(this, NOSAVE, "scope_channel");
	useScope.init(this, NOSAVE, "scope_mode");
	totalChannels.init(this, NOSAVE, "total_channels");
	useScopeStr.init(this, NOSAVE, "scope_mode_str");
	usePn1Coincidence.init(this, SAVE, "pn1_coincidence");
	liveProcessType.init(this, SAVE, "live_process_type");

	boardIndex.init(this, NOSAVE, "board_index");
	channelsPerBoard.init(this, NOSAVE, "channels_per_board");

	m_AcquisitionMode = AcquisitionCommon::PULSE_PROCESSING_MODE;

	registerFunction(TYPE);

	m_histogramController.init(this, "histogram_controller");
	m_coincidenceController.init(this, "coincidence_controller");

	registerRefresher(nbAdcControllers, &DPPAcquisitionController::refreshNbAdcControllersProperty, this);
}

/*
 * Destructor
 */
DPPAcquisitionController::~DPPAcquisitionController() {

}

/*
 * postConfiguration
 */
void DPPAcquisitionController::postConfiguration() {

	TimeAcquisitionController::postConfiguration();

	// Copy local ptr for setting the write type cast
	dppDriver.resize(m_nRegisteredDrivers);
	for (int32 i = 0; i < m_nRegisteredDrivers; ++i) {
		dppDriver[i].copy(m_Drivers[i]);
		registerUpdater(dppDriver[i]->curve0, &DPPAcquisitionController::updateCurve0ArrayProperty, this, i);
		registerUpdater(dppDriver[i]->curve1, &DPPAcquisitionController::updateCurve1ArrayProperty, this, i);
		registerUpdater(dppDriver[i]->curve2, &DPPAcquisitionController::updateCurve2ArrayProperty, this, i);
		registerUpdater(dppDriver[i]->curve3, &DPPAcquisitionController::updateCurve3ArrayProperty, this, i);
		registerUpdater(dppDriver[i]->curve4, &DPPAcquisitionController::updateCurve4ArrayProperty, this, i);
	}

	registerRefresher(usePn1Coincidence, &DPPAcquisitionController::refreshUsePn1CoincidenceModeProperty, this);
	registerRefresher(nbBits, &DPPAcquisitionController::refreshNbBitsProperty, this);

	for (int32 i = 0; i < nbAdcControllers(); ++i) {
		registerUpdater(adcController[i]->dppAcqMode, &DPPAcquisitionController::updateUseScopeProperty, this, i);
		registerUpdater(adcController[i]->displayChannel, &DPPAcquisitionController::updateUseScopeProperty, this, i);
		registerUpdater(adcController[i]->channels, &DPPAcquisitionController::setChannelsPerBoard, this);
		registerUpdater(adcController[i]->recordLength, &DPPAcquisitionController::updateRecordLengthProperty, this, i);
	}

	setChannelsPerBoard();
	setScopeMode();
	setCrateNumber();

	registerRefresher(liveProcessType, &DPPAcquisitionController::refreshLiveProcessTypeProperty, this);
}

/*
 * refreshNDriversProperty
 */
void DPPAcquisitionController::refreshNDriversProperty(int32 aValue) throw (CannotSetValue) {

	boardIndex.resize(aValue);
	channelsPerBoard.resize(aValue);

	TimeAcquisitionController::refreshNDriversProperty(aValue);
}

/*
 * refreshNbAdcControllersProperty
 */
void DPPAcquisitionController::refreshNbAdcControllersProperty(int32 aValue) throw (CannotSetValue) {

	if (aValue == nbAdcControllers()) {
		return;
	}
	adcController.resize(aValue);

	for (int32 i = 0; i < aValue; ++i) {
		string controllerName = "adc_controller" + lexical_cast<string>(i + 1);
		adcController[i].init(this, controllerName);
	}

}

/*
 * updateRecordLengthProperty
 */
void DPPAcquisitionController::updateRecordLengthProperty(int32 index) {
	int32 rencordlength = adcController[index]->recordLength();
	for (int32 i = 0; i < m_nRegisteredDrivers; ++i) {
		dppDriver[i]->recordLength = rencordlength;
	}
}

/*
 * updateCurve0ArrayProperty
 */
void DPPAcquisitionController::updateCurve0ArrayProperty(int32 index) {

	for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
		adcController[adc]->curve0.update(dppDriver[index]->curve0());
		adcController[adc]->curve0.setSize(dppDriver[index]->curve0.getSize());
		adcController[adc]->curve0.sendEvent();
	}
}

/*
 * updateCurve1ArrayProperty
 */
void DPPAcquisitionController::updateCurve1ArrayProperty(int32 index) {

	for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
		adcController[adc]->curve1.update(dppDriver[index]->curve1());
		adcController[adc]->curve1.setSize(dppDriver[index]->curve1.getSize());
		adcController[adc]->curve1.sendEvent();
	}
}

/*
 * updateCurve2ArrayProperty
 */
void DPPAcquisitionController::updateCurve2ArrayProperty(int32 index) {

	for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
		adcController[adc]->curve2.update(dppDriver[index]->curve2());
		adcController[adc]->curve2.setSize(dppDriver[index]->curve2.getSize());
		adcController[adc]->curve2.sendEvent();
	}
}

/*
 * updateCurve3ArrayProperty
 */
void DPPAcquisitionController::updateCurve3ArrayProperty(int32 index) {

	for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
		adcController[adc]->curve3.update(dppDriver[index]->curve3());
		adcController[adc]->curve3.setSize(dppDriver[index]->curve3.getSize());
		adcController[adc]->curve3.sendEvent();
	}
}

/*
 * updateCurve4ArrayProperty
 */
void DPPAcquisitionController::updateCurve4ArrayProperty(int32 index) {

	for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
		adcController[adc]->curve4.update(dppDriver[index]->curve4());
		adcController[adc]->curve4.setSize(dppDriver[index]->curve4.getSize());
		adcController[adc]->curve4.sendEvent();
	}
}

/*
 * updateUseScopeProperty
 */
void DPPAcquisitionController::updateUseScopeProperty(int32 index) {

	int32 boardChannel = 0;
	int32 aValue = adcController[index]->dppAcqMode();

	if (aValue == acquisition::DPPAcquisitionCommon::SCOPE_MODE) {
		for (int32 i=0; i<nbAdcControllers(); ++i) {
			if (i != index) {
				adcController[i]->dppAcqMode = acquisition::DPPAcquisitionCommon::LISTMODE_MODE;
			}
		}
		useScope = 1;
		useScopeStr = "Active";
		for (int32 i=0; i<index; ++i) {
			boardChannel += adcController[i]->channels();
		}
		boardChannel += adcController[index]->displayChannel();
		useListMode = 0;
		usePn1Coincidence = 0;
	}
	else if (aValue == acquisition::DPPAcquisitionCommon::LISTMODE_MODE) {
		useScope = 0;
		useScopeStr = "Inactive";
	}

	scopeChannel = boardChannel;
	int32 board = adcController[index]->acqBoardIndex();
	dppDriver[board]->useScope = useScope();
	dppDriver[board]->scopeChannel = boardChannel;
	dppDriver[board]->scopeCardActivated = adcController[index]->modelName();
	dppDriver[board]->recordLength =  adcController[index]->recordLength();
	dppDriver[board]->useListMode = useListMode();
	dppDriver[board]->usePn1Coincidence = usePn1Coincidence();
}

/*
 * refreshUseListModeProperty
 */
void DPPAcquisitionController::refreshUseListModeProperty(int32 aValue) throw (CannotSetValue) {

	for (int32 board=0; board<nDrivers(); ++board) {
		dppDriver[board]->useListMode = aValue;
	}

	if (aValue == 1) {
		for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
			adcController[adc]->dppAcqMode = acquisition::DPPAcquisitionCommon::LISTMODE_MODE;
		}
	}
}

/*
 * refreshUseListModeProperty
 */
void DPPAcquisitionController::refreshUsePn1CoincidenceModeProperty(int32 aValue) throw (CannotSetValue) {

	for (int32 board=0; board<nDrivers(); ++board) {
		dppDriver[board]->usePn1Coincidence = aValue;
		dppDriver[board]->gateWidth = gateWidth();
	}

	if (aValue == 1) {
		for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
			adcController[adc]->dppAcqMode = acquisition::DPPAcquisitionCommon::LISTMODE_MODE;
		}
	}
}

/*
 * refreshNbBitsProperty
 */
void DPPAcquisitionController::refreshNbBitsProperty(int32 aValue) throw (CannotSetValue) {

	for (int32 i = 0; i < m_nRegisteredDrivers; ++i) {
		dppDriver[i]->nbBits = aValue;
	}
}

/*
 * refreshLiveProcessTypeProperty
 */
void DPPAcquisitionController::refreshLiveProcessTypeProperty(const std::string& aValue) throw (CannotSetValue) {

	m_histogramController->raz();
	m_coincidenceController->raz();

	if (aValue == HISTOGRAM_PROCESS) {
		m_liveProcessController = m_histogramController;
	} else if (aValue == COINCIDENCE_PROCESS) {
		m_liveProcessController = m_coincidenceController;
	} else {
		m_liveProcessController.assign(0);
	}
}

/*
 * resize
 */
void DPPAcquisitionController::resize() throw (CannotOpenFile, SlicesFileError, TooManySlices, SliceTooBig) {

	int32 resolution = (int32) pow(2.0, nbBits());
	m_Detector->setDataSize(resolution, 1);
}

/*
 * writeParams
 */
void DPPAcquisitionController::writeParams() {

	int32 totalAdc = 0;
	for (int32 i = 0; i < nDrivers(); ++i) {
		totalAdc += channelsPerBoard.get(i);
	}
	totalChannels = totalAdc;

	log(Level::s_Debug) << name << cursor << "Sending DPP parameters to acquisition card : listmode " << useListMode()
			<< " , wanted adc " << totalChannels() << " , wanted resolution " << nbBits() << endlog;

	Parallel::begin();
	for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
		adcController[adc]->clearDataParallel();
	}
	Parallel::end();

	if (isModeChanged() == true) {

		Parallel::begin();
		for (int32 i = 0; i < nDrivers(); ++i) {
			dppDriver[i]->wantedMode = m_AcquisitionMode;
			dppDriver[i]->nbBits = nbBits();
			dppDriver[i]->nbChannels = channelsPerBoard.get(i);
			dppDriver[i]->scopeChannel = scopeChannel();
			dppDriver[i]->gateWidth = gateWidth();
			dppDriver[i]->usePn1Coincidence = usePn1Coincidence();
			dppDriver[i]->useListMode = useListMode();
			dppDriver[i]->useScope = useScope();

			/*
			 * Execute the write param command
			 */
			dppDriver[i].executeParallel(AcquisitionCommon::WRITE_PARAMETERS_COMMAND);
		}
		Parallel::end();

		/*
		 * Execute the write param command
		 */
		for (int32 i = 0; i < nDrivers(); ++i) {
			dppDriver[i].execute(AcquisitionCommon::LIST_MODE_COMMAND, false, true);
		}

		// starting DPPCoincidence
		if (useListMode() && m_liveProcessController.isAssigned()) {

			m_liveProcessController->numberOfADCs = totalAdc;
			m_liveProcessController->numberOfChannels = (1 << nbBits());

			// set the lst context
			setContext();

			// start the process in parallel to avoid blocking
			m_liveProcessController->startParallel();

			if (checkStatus() == true) {
				log(Level::s_Debug) << name << emptycursor << "DPP parameters accepted by acquisition card(s): " << totalAdc
						<< " x " << nbBits() << endlog;
			}
		}
	}
}

/*
 * stop
 */
void DPPAcquisitionController::stop() {

	TimeAcquisitionController::stop();

	// stopping DPPCoincidence
	if (m_liveProcessController.isAssigned()) {
		m_liveProcessController->stopCommand();
	}
}

/*
 * useEnergy
 */
bool DPPAcquisitionController::useEnergy() const {
	return true;
}

void DPPAcquisitionController::setScopeMode() {

	int32 scope = 0;
	int32 boardChannel = 0;
	int32 index = 0;
	for (int32 board=0; board<nDrivers(); ++board) {
		for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
			if (adcController[adc]->dppAcqMode() == acquisition::DPPAcquisitionCommon::SCOPE_MODE) {
				index = adc;
				scope = 1;
				useScopeStr = "Active";
			} else {
				useScopeStr = "Inactive";
			}
		}
		if (scope == 1) {
			for (int32 i=0; i<index; ++i) {
				boardChannel += adcController[i]->channels();
			}
			boardChannel += adcController[index]->displayChannel();
			scopeChannel = boardChannel;
		}
		dppDriver[board]->useScope = scope;
		dppDriver[board]->scopeChannel = boardChannel;
		dppDriver[board]->scopeCardActivated = adcController[index]->modelName();
		dppDriver[board]->recordLength =  adcController[index]->recordLength();
		dppDriver[board]->useListMode = useListMode();
		dppDriver[board]->usePn1Coincidence = usePn1Coincidence();
	}
	useScope = scope;
}

void DPPAcquisitionController::setChannelsPerBoard() {

	for (int32 board=0; board<nDrivers(); ++board) {
		int32 totalChannels = 0;
		for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
			if (adcController[adc]->acqBoardIndex() == board) {
				totalChannels += adcController[adc]->channels();
			}
		}
		boardIndex.set(board, board);
		channelsPerBoard.set(board, totalChannels);
		dppDriver[board]->nbChannels = totalChannels;
	}
}

void DPPAcquisitionController::setCrateNumber() {
	for (int32 board=0; board<nDrivers(); ++board) {
		for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
			if (adcController[adc]->acqBoardIndex() == board) {
				adcController[adc]->crateNumber = dppDriver[board]->crateNumber();
			}
		}
	}
}

/**
 * Warning: we suppose that the list mode block is ordered like the ADC controllers
 */
void DPPAcquisitionController::setContext() {

	releaseListModeContext(listModeContext);

	int32 nbCrates = 0;

	for (int32 adc = 0; adc < nbAdcControllers(); ++adc) {
		int32 crate = adcController[adc]->crateNumber();
		if (crate >= nbCrates) {
			nbCrates = crate + 1;
		}
	}

	listModeContext.crateBoard.nbCrates = nbCrates;
	listModeContext.crateBoard.crates = new Crate[nbCrates];

	for (int32 crate = 0; crate < nbCrates; ++crate) {
		int32 nbBoards = 0;

		for (int32 board = 0; board < nbAdcControllers(); ++board) {
			if (board >= nbBoards) {
				nbBoards = board + 1;
			}
		}

		listModeContext.crateBoard.crates[crate].nbBoards = nbBoards;
		listModeContext.crateBoard.crates[crate].boards = new Board[nbBoards];

		for (int32 board = 0; board < nbAdcControllers(); ++board) {
			listModeContext.crateBoard.crates[0].boards[board].boardType = (BoardType)adcController[board]->cardType();
			listModeContext.crateBoard.crates[0].boards[board].crate = crate;
			listModeContext.crateBoard.crates[0].boards[board].eventType = 0;
			listModeContext.crateBoard.crates[0].boards[board].nbChannels = adcController[board]->nbChannels();
		}
	}

	cout << "context before live process" << endl;
	cout << listModeContext << endl;
}

}