#include "ECTrainer.h"
#include "ECTrainerGUI.h"
#include "SceneCamera.h"
#include "Stimulus.h"
#include "Marker.h"
#include "ImageProc.h"
#include "EyeTrack.h"

// コンストラクタ
ECTrainer::ECTrainer()
	: _pGui(NULL)
	, _pSceneCam(NULL)
	, _pStimulus(NULL)
	, _pMarker(NULL)
	, _pImageProc(NULL)
	, _pEyeTrack(NULL)
	, _Running(true)
	, _HomographyOK(false)
{
	_pMarker = new Marker();
	_pGui = new ECTrainerGUI(this);
	_pImageProc = new ImageProc(this, _pMarker);
	_pSceneCam = new SceneCamera(this, _pImageProc);
	_pStimulus = new Stimulus(this, _pMarker);
	_pEyeTrack = new EyeTrack(this, _pMarker);
}

// デストラクタ
ECTrainer::~ECTrainer() {
	if (_pGui) delete _pGui;
	if (_pSceneCam) delete _pSceneCam;
	if (_pStimulus) delete _pStimulus;
	if (_pMarker) delete _pMarker;
	if (_pImageProc) delete _pImageProc;
	if (_pEyeTrack) delete _pEyeTrack;
}

// 初期化
bool ECTrainer::Process() {
	if (!_pGui->Init()) return false;
	if (!_pSceneCam->Init()) return false;
	if (!_pStimulus->Init()) return false;
	if (!_pImageProc->Init()) return false;
	if (!_pEyeTrack->Init()) return false;

	DWORD dwThreadIdSceneCam, dwThreadIdStimulus, dwThreadIdImageProc, dwThreadIdEyeTrack, dwThreadIdKeepAlive;
	HANDLE hThreadSceneCam = CreateThread(NULL, 0, SceneCamThreadEntry, this, 0, &dwThreadIdSceneCam);
	HANDLE hThreadStimulus = CreateThread(NULL, 0, StimulusThreadEntry, this, 0, &dwThreadIdStimulus);
	HANDLE hThreadImageProc = CreateThread(NULL, 0, ImageProcThreadEntry, this, 0, &dwThreadIdImageProc);
	HANDLE hThreadEyeTrack = CreateThread(NULL, 0, EyeTrackThreadEntry, this, 0, &dwThreadIdEyeTrack);
	HANDLE hThreadKeepAlive = CreateThread(NULL, 0, KeepAliveThreadEntry, this, 0, &dwThreadIdKeepAlive);

	_pGui->MainLoop();

	HANDLE handles[] = { hThreadSceneCam , hThreadStimulus, hThreadImageProc, hThreadEyeTrack, hThreadKeepAlive };
	DWORD timeOut = 1000; // タイムアウト(ms)
	if (WaitForMultipleObjects(sizeof(handles) / sizeof(HANDLE), handles, TRUE, timeOut) != WAIT_TIMEOUT) {
		OutputDebugString(_T("All threads stopped sccessfully.\n"));
	} else {
		OutputDebugString(_T("Waiting threads stop timeout.\n"));
	}
	if (hThreadSceneCam) CloseHandle(hThreadSceneCam);
	if (hThreadStimulus) CloseHandle(hThreadStimulus);
	if (hThreadImageProc) CloseHandle(hThreadImageProc);
	if (hThreadEyeTrack) CloseHandle(hThreadEyeTrack);
	if (hThreadKeepAlive) CloseHandle(hThreadKeepAlive);

	return true;
}

// キャリブレーション
void ECTrainer::Calib() {
	_pStimulus->Calibration();
}

// 開始
void ECTrainer::Start() {
	_pStimulus->Start();
}

// 次へ
void ECTrainer::Next() {
	_pStimulus->Next();
}

// 視野画像バッファに画像を設定
void ECTrainer::SetSceneBuffer(cv::Mat& img) {
	_pGui->SetSceneBuffer(img);
}

// 刺激画像バッファに画像を設定
void ECTrainer::SetDispBuffer(cv::Mat& img) {
	_pGui->SetDispBuffer(img);
}

// 視野カメラスレッド開始点
DWORD WINAPI ECTrainer::SceneCamThreadEntry(LPVOID lpParameter) {
	((ECTrainer*)lpParameter)->_pSceneCam->MainLoop();
	return 0;
}

// 刺激画像スレッド開始点
DWORD WINAPI ECTrainer::StimulusThreadEntry(LPVOID lpParameter) {
	((ECTrainer*)lpParameter)->_pStimulus->MainLoop();
	return 0;
}

// 画像処理スレッド開始点
DWORD WINAPI ECTrainer::ImageProcThreadEntry(LPVOID lpParameter) {
	((ECTrainer*)lpParameter)->_pImageProc->MainLoop();
	return 0;
}

// 注視点スレッド開始点
DWORD WINAPI ECTrainer::EyeTrackThreadEntry(LPVOID lpParameter) {
	((ECTrainer*)lpParameter)->_pEyeTrack->MainLoop();
	return 0;
}

// KeepAliveスレッド開始点
DWORD WINAPI ECTrainer::KeepAliveThreadEntry(LPVOID lpParameter) {
	((ECTrainer*)lpParameter)->_pEyeTrack->KeepAliveLoop();
	return 0;
}

// 視野画像中の注視点設定
void ECTrainer::SetGazeV(cv::Point gazeV) {
	_pEyeTrack->SetGazeV(gazeV); 
}

// 視野画像中の注視点取得
cv::Point ECTrainer::GetGazeV() {
	return _pEyeTrack->GetGazeV();
}

// 刺激画像中の注視点取得
cv::Point2f ECTrainer::GetGazeI() {
	return _pEyeTrack->GetGazeI();
}

// 右目の位置取得
cv::Point2f ECTrainer::GetEyeR() {
	return _pStimulus->GetEyeR();
}

// 右目の位置取得
cv::Point2f ECTrainer::GetEyeL() {
	return _pStimulus->GetEyeL();
}