// ---------------------------------------------------------------------------------------------------------------------------------------------------
//
std::time_t ofxAutoReloadedShader::getLastModified( ofFile& _file )
{
	if( _file.exists() )
	{
        return std::filesystem::last_write_time(_file.path());
	}
	else
	{
		return 0;
	}
}

std::time_t UIShader::getLastModified( ofFile& _file ){
	if( _file.exists() ){
		Poco::File& pocoFile		= _file.getPocoFile();
		Poco::Timestamp timestamp	= pocoFile.getLastModified();
		std::time_t fileChangedTime = timestamp.epochTime();
		
		return fileChangedTime;
	} else {
		return 0;
	}
}

//--------------------------------------------------------------
void ofApp::processFile(ofFile & file) {
	cout << file.getAbsolutePath() << endl;
	auto extension = ofToLower(file.getExtension());
	cout << extension << endl;
	if (extension == "jpg" || extension == "jpeg" || extension == "png") {
		ofImage loader;
		ofLogNotice("ofApp::dragEvent") << "loading " << file.getFileName() << " #" << decoder.getFrame();
		loader.loadImage(file);
		ofLogNotice("ofApp::dragEvent") << "adding " << file.getFileName();
		decoder << loader;
	} else if (extension == "sl") {
		this->decoder.loadDataSet(file.getAbsolutePath());
	}
}

long getUpdateTime(ofFile &file) {
	struct stat fileStat;
    if(stat(file.path().c_str(), &fileStat) < 0) {
		printf("Couldn't stat file\n");
		return;
	}

	return fileStat.st_mtime;
}

//--------------------------------------------------------------
void ArtvertiserApp::artvertSelected(ofFile & artvertimg){
	

	subs_img.setup( artvertimg.getAbsolutePath() );

	state = Tracking;
	artvertInfo.stop();
	Artvert & artvert = artvertInfo.getCurrentArtvert();

	if(artvert.hasAlias()){
		artvertiser.setup(artvert.getAlias().getModel().getAbsolutePath(),grabber,subs_img.getImgQuad(), false, detectW, detectH );
		ofLogVerbose("ArtvertiserApp", "artvert.hasAlias()");
	}else{
		ofLogVerbose("ArtvertiserApp", "doesn't: artvert.hasAlias()");
		artvertiser.setup(artvert.getModel().getAbsolutePath(),grabber,subs_img.getImgQuad(), false, detectW, detectH );
	}
}

void ofImage_<PixelType>::saveImage(const ofFile & file, ofImageQualityType compressionLevel){
	ofSaveImage(pixels,file.getAbsolutePath(),compressionLevel);
}

bool ofImage_<PixelType>::loadImage(const ofFile & file){
	return loadImage(file.getAbsolutePath());
}

bool ofImage_<PixelType>::load(const ofFile & file, const ofImageLoadSettings &settings){
	return load(file.getAbsolutePath(), settings);
}

//--------------------------------------------------------------
void testApp::setup(){
    
    ofBackground(0);
    ofSetFrameRate(60);
    
    int PORT = 12000;
    int REMOTE_PORT = 12000;
    string REMOTE_HOST = "169.254.0.1";
    
	receiver.setup(PORT);
    sender.setup(REMOTE_HOST, REMOTE_PORT);
    
    sprintf(oscStatus, "[LOCALPORT] %d\n[REMOTE PORT] (%s, %5d)\n", PORT, REMOTE_HOST.c_str(), REMOTE_PORT);
    
    gui.setup();
	gui.addTitle("TRACKER \n[i] hide controls");
    gui.addToggle("TRACK", bTracking).setSize(200, 20);
    calibratedButton = &gui.addToggle("CALIBRATED", bCalibrated);
    calibratedButton->setSize(200, 20);
    gui.addToggle("SAVE", bSaving).setSize(200, 20);
    gui.addButton("Load MeshLab File", bLoadMLP).setSize(200, 20);
    gui.addButton("Reset Server Counter", bReset).setSize(200, 20);

    gui.addSlider("Zoom", camZoom, -5000, 5000).setSmoothing(0.9);
    gui.addSlider("camPosX", camPosX, -200, 200).setSmoothing(0.9);
    gui.addSlider("camPosY", camPosY, -200, 200).setSmoothing(0.9);
    gui.addSlider("camRotX", camRotX, 0, 360).setSmoothing(0.9);
    gui.addSlider("camRotY", camRotY, 0, 360).setSmoothing(0.9);
    gui.addToggle("Lock top view", bTop).setSize(200, 20);
    gui.addToggle("Enable ghost 1", bGhost0).setSize(200, 20);
    gui.addToggle("Enable ghost 2", bGhost1).setSize(200, 20);
    
    
    gui.addButton("Set Center", bSetCenter).setSize(200, 20);
    gui.addButton("Set Ref Point", bSetRefPoint).setSize(200, 20);
    gui.addButton("Set Ghost 1", bSetGhost0).setSize(200, 20);
    gui.addButton("Set Ghost 2", bSetGhost1).setSize(200, 20);
    status = &gui.addTitle("STATUS");
    status->setNewColumn(true);
    
	gui.loadFromXML();
    gui.show();
    
    matrixData.setup();
    
    // LOAD space references
    
    XML.loadFile(ofToDataPath("xmlSettings.xml"));
    int cX = XML.getValue("CENTER_X", 0);
    int cZ = XML.getValue("CENTER_Z", 0);
    int rX = XML.getValue("REF_X", 0);
    int rZ = XML.getValue("REF_Z", 0);
    
    center = ofVec3f(cX, 0, cZ);
    refPoint = ofVec3f(rX, 0,  rZ);
    refVector = center - refPoint;
    
    
    for(int i = 0; i < K; i++){
        kinects[i].setMatrix(matrixData.getMatrix(i));
        kinects[i].setCenter(center, refVector);
    }
    
    // LOAD GHOSTS
    int gX, gZ;
    
    gX = XML.getValue("GHOST_0_X", 0);
    gZ = XML.getValue("GHOST_0_Z", 0);
    ghost0 = ofVec3f(gX, 0, gZ);
    
    gX = XML.getValue("GHOST_1_X", 0);
    gZ = XML.getValue("GHOST_1_Z", 0);
    ghost1 = ofVec3f(gX, 0, gZ);
    
    //-----
    
    
    bTracking = false;
    bCalibrated = false;
    bSaving = false;
    pbSaving = false;
    bReset = false;
    bTop = false;
    
    
    // Purge old osc messages
    while(receiver.hasWaitingMessages()){
		ofxOscMessage m;
		receiver.getNextMessage(&m);
    }

  
    logFile.open("log.txt", ofFile::WriteOnly, false);
    /*
    AAAAAdasdasdadsa
    bGhost0 = true;
    bGhost1 = true;
     */
}

template <class T> void writeRaw(ofFile& out, T data) {
	out.write((char*) &data, sizeof(data)); 
}

template <class T> void readRaw(ofFile& in, T& data) {
	in.read((char*) &data, sizeof(data)); 
}

// Create the clusters out of the image
ImgTexture ImgTextureFactory::CreateImage(const ofFile& inImageFile, const ofFile& inClusterFile)
{
	std::cout << "\nCreating Image: " << inImageFile.getFileName() << "\n";

	std::cout << "\nCreating Clustered Image: " << inClusterFile.getFileName() << "\n";

	// First create an image out of the incoming file, this can have any format
	ofImage image;
	image.loadImage(inImageFile);
	assert(image.isAllocated());

	// Load our clustered image in a pixel buffer
	ofPixels clustered_pix;
	ofLoadImage(clustered_pix, inClusterFile.getFileName());

	/*
	// Load our sample image in a pixel buffer
	ofPixels clustered_sample_pix;
	ofLoadImage(clustered_pix, inClusterFile.getFileName());
	*/

	// Now create our clustered image, this needs to be of a type (rgba, 8bc)
	assert(clustered_pix.isAllocated());
	assert(clustered_pix.getImageType() == OF_IMAGE_COLOR_ALPHA);
	assert(clustered_pix.getBitsPerPixel() == 32);

	// Will hold the final amount of clusters
	int cluster_counter = 0;

	// Used for storing the color value
	std::vector<BYTE>			colors;
	std::vector<int>			color_refs;

	// Now get the pixels and iterate over them
	// We sample how many clusters there are in the image,
	// The colors that belong to that cluster and how many times that color appears in the image
	BYTE* pixels = clustered_pix.getPixels();
	for (int x=0; x < clustered_pix.getWidth(); x++)
	{
		for(int y=0; y < clustered_pix.getHeight(); y++)
		{
			// Get the current read pos and sample color
			int read_pos = ((y*clustered_pix.getWidth())+ x) * 4;

			// Make sure alpha is not 0
			if(pixels[read_pos+3] < 2)
				continue;

			BYTE color = pixels[read_pos];

			// See if it's in the colors array, if not add
			bool	already_present = false;
			int		color_counter = 0;
			for(std::vector<BYTE>::iterator it = colors.begin(); it != colors.end(); ++it) 
			{
				// Get the color and sample within a range
				BYTE p_color = *it;
				if(!(color > *it+2) && !(color < *it-2))
				{
					already_present = true;
					(color_refs[color_counter])++;
					break;
				}

				// Increment color counter
				color_counter++;
			}

			if(!already_present)
			{
				colors.push_back(color);
				color_refs.push_back(1);
				cluster_counter++;
			}
		}
	}

	// Now delete the clusters that don't have enough pixels
	std::vector<BYTE> final_color_set;
	int counter = 0;
	int fclusters = 0;
	for(std::vector<int>::iterator it = color_refs.begin(); it != color_refs.end(); ++it)
	{
		if(*it >= MIN_CLUSTER_PIXEL_COUNT)
		{
			final_color_set.push_back(colors[counter]);
			fclusters++;
		}
		counter++;
	}

	// Sort the remaining ones based on color
	vector<BYTE>::iterator it;
	sort(final_color_set.begin(), final_color_set.end());

	// Return a new texture that holds the image and clusters
	return ImgTexture(image, clustered_pix, fclusters, final_color_set);
}

	void watch(string vertName, string fragName)
	{
		vertShader.open(vertName);
		fragShader.open(fragName);
		
		ofAddListener(ofEvents().update, this, &AutoLoadShader::onUpdate);
	}

	void onUpdate(ofEventArgs &e)
	{
		if (lastVertTimestamp != vertShader.getPocoFile().getLastModified()
			|| lastFragTimestamp != fragShader.getPocoFile().getLastModified())
		{
			reload();
		}
	}

void testApp::writeLog(){
    //-------------------------
    // Writing machine learning data
    if(bTracking && bCalibrated){
        state = 0; // state is used for machine learning mark-up
        if(keys['1']) state = 1;
        if(keys['2']) state = 2;
       // if(keys['3']) state = 3;
       
        
       logFile << trackers[0].lerpedPos.x << " " << trackers[0].lerpedPos.z << " "
        << trackers[1].lerpedPos.x << " " << trackers[1].lerpedPos.z << " "
        << trackers[2].lerpedPos.x << " " << trackers[2].lerpedPos.z << " " << state << endl;
        
        cout << trackers[0].lerpedPos.x << " " << trackers[0].lerpedPos.z << " "
        << trackers[1].lerpedPos.x << " " << trackers[1].lerpedPos.z << " "
        << trackers[2].lerpedPos.x << " " << trackers[2].lerpedPos.z << " " << state << endl;
        logFile.flush();
    }
}

	void reload()
	{
		load(vertShader.path(), fragShader.path());
	}