#pragma once

#define IMAGE_STORE_SIZE 256

#define MIN_TILE_SIZE 8
#define MAX_TILE_SIZE 32

#define FLANN_MATRIX_SIZE 5

#define INSTAGRAM_DISPLAY_TIME 5
#define IMAGE_FREEZE_TIME 5

#include "ofMain.h"
#include "ofxJSONElement.h"
#include "ofxOpenCv.h"
//#include <opencv/include/opencv2/flann/flann.hpp>

//~9fps@33% 32*3

using namespace cvflann;

long ofToLong(const string& intString);

class imageStore : public ofThread{

	public:

		float interval; //time between refreshes in seconds

		std::string instagram_url;
		ofxJSONElement response;
		std::map<std::string,ofImage> images;
		vector<ofImage*> imageptrs;
		deque<std::string> to_update;
		bool newinstagram;
		ofImage instagram_image;
		float newinstagramtime;

		//Matrix<float> dataset; doesn't need to be retained?

		//need to be able to add arbitrary data and keep it?
		//see pucilar behaviour if we delete the data after indexing it
		//we see some puzzling performance anomalies if we add data
		//maybe rebuild the index rather than use index.addPoints()
		//this way the data can be kept contiguously
		//or maybe just get a pointer to vector data with an offset
		vector<float> data;
		//to begin, get a single point per image

		//retain a pointer to the flann indexer
		Index<L2<float> >* index;

		//Index<L2<float> > index(dataset, cv::flann::KDTreeIndexParams(4));

		imageStore(){
			instagram_url = "https://api.instagram.com/v1/tags/tycleeson/media/recent?client_id=c1d74d701fdf4ddd9f8d30ee9e8f944b";
			interval=5.00f;
			ofImage img;
			img.allocate(MAX_TILE_SIZE,MAX_TILE_SIZE,OF_IMAGE_COLOR);
			img.clear();
			img.setUseTexture(true);
			img.update();
			images["000000"]=img;
			//colours["000000"]=ofColor(0,0,0);
			newinstagram=false;
		}
		~imageStore(){
			delete index;
		}

		void set_interval(float _interval){
			interval=_interval;
		}

		void start(){
            startThread(true, false);   // blocking, verbose
        }

        void stop(){
            stopThread();
        }

        //naive implementation
        //too slow!
        //looks shit!

        //how to make the search algorithm faster and better
        //http://www.semanticmetadata.net/lire/

        std::map<std::string,ofColor> colours;
        ofImage& get_image(const ofColor& col){
        	//float shortest_dist=999999.0f;
        	int sd=1000;
        	ofImage& im=images.begin()->second;
        	if( lock() ){
	        	std::string s=images.begin()->first;
	        	for (map<string,ofImage>::iterator it=images.begin();it!=images.end();++it){
	        		ofColor& c=colours[it->first];
	        		int rd=c.v[0]-col.v[0];
	        		int gd=c.v[1]-col.v[1];
	        		int bd=c.v[2]-col.v[2];
	        		//float dist=pow((float)((rd*rd)+(gd*gd)+(bd*bd)),0.5);
	        		int dist=abs(rd)+abs(gd)+abs(bd);
	        		if (dist<sd){
	        			sd=dist;
	        			im=it->second;
	        			s=it->first;
	        		}
	        	}
	        	unlock();
	    	}
        	//cerr<<"got image "<<s<<endl;
        	return im;
        }

        ofImage& get_image(float r,float g,float b){
        	ofImage& im=images.begin()->second;
        	if( lock() ){
	        	float* test=new float[3];
	        	test[0]=r;
	        	test[1]=g;
	        	test[2]=b;
	        	Matrix<float> query(test,1,3);
	        	Matrix<int> indices(new int[1], query.rows, 1);
	    		Matrix<float> dists(new float[1], query.rows, 1);
	    		index->knnSearch(query, indices, dists, 1,SearchParams(20));
	    		im=*imageptrs[*indices[0]];
	    		//int i=rand()%imageptrs.size();
	    		//im=images[imageptrs[i]];
	    		//cerr<<"returning image "<<i<<endl;
	    		unlock();
	    	}
	    	return im;
        }

        ofImage& get_image(float* data){
        	ofImage& im=images.begin()->second;
        	if( lock() ){
	        	Matrix<float> query(data,1,FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE*3);
	        	Matrix<int> indices(new int[1], query.rows, 1);
	    		Matrix<float> dists(new float[1], query.rows, 1);
	    		index->knnSearch(query, indices, dists, 1,SearchParams(4));
	    		im=*imageptrs[*indices[0]];
	    		//int i=rand()%imageptrs.size();
	    		//im=images[imageptrs[i]];
	    		//cerr<<"returning image "<<i<<endl;
	    		unlock();
	    	}
	    	return im;
        }

        ofColor get_colour(const ofImage& _img){
        	ofImage img=_img;
        	img.resize(1,1);
        	return ofColor(img.getPixels()[0],img.getPixels()[1],img.getPixels()[2]);
        }

        void add_data(const ofImage& _img){
        	ofImage img=_img;
        	img.resize(FLANN_MATRIX_SIZE,FLANN_MATRIX_SIZE);
        	for (int i=0;i<FLANN_MATRIX_SIZE;i++){
        		for (int j=0;j<FLANN_MATRIX_SIZE;j++){
        			data.push_back(img.getPixels()[(j*FLANN_MATRIX_SIZE+i)*3]);
        			data.push_back(img.getPixels()[(j*FLANN_MATRIX_SIZE+i)*3+1]);
        			data.push_back(img.getPixels()[(j*FLANN_MATRIX_SIZE+i)*3+2]);
        		}
        	}
        }

        bool new_instagram(){
        	if (newinstagram){
    			if( lock() ){
    				loadtexture(instagram_image);
        			newinstagram=false;
        			newinstagramtime=ofGetElapsedTimef();
		        	unlock();
		        	return true;
				}
        	}
        	return false;
        }

        bool drawinstagram(int x,int y,int w,int h){
			if( lock() ){
				instagram_image.draw(x,y,w,h);
	        	unlock();
			}
			if (ofGetElapsedTimef()-newinstagramtime>INSTAGRAM_DISPLAY_TIME) return false;
			return true;
		}

		void instagram_floats(float* floatImage){
			if( lock() ){

				int size=ceil(ofGetHeight()/MAX_TILE_SIZE)*FLANN_MATRIX_SIZE;
				ofImage imm=instagram_image;
				imm.resize(size,size);
				uint8_t* cptr=imm.getPixels();
				for (int i=0;i<size;i++){
					for (int j=0;j<size;j++){
						floatImage[(i*size+j)*3]=cptr[(i*size+j)*3];
						floatImage[(i*size+j)*3+1]=cptr[(i*size+j)*3+1];
						floatImage[(i*size+j)*3+2]=cptr[(i*size+j)*3+2];
					}
				}
				unlock();
			}
		}

        //void flann(const ofImage& _img){

		//--------------------------
		void threadedFunction(){

			//1st get the pre-existing images

			ofDirectory image_path(ofToString(IMAGE_STORE_SIZE)+"/");
			cerr<<"image path: "<<image_path.getAbsolutePath()<<endl;
			if( lock() ){ //lock the thread while preparing the initial images
				if (image_path.exists()){
					image_path.listDir();
					cerr<<"image path found, "<<image_path.size()<<" images"<<endl;
					for (int i=0;i<image_path.size();i++){
						ofImage img;
						img.setUseTexture(false);
						img.loadImage(ofToString(IMAGE_STORE_SIZE)+"/"+image_path.getFiles()[i].getFileName());
						
						if (i==image_path.size()-1) instagram_image=img;

						img.resize(MAX_TILE_SIZE,MAX_TILE_SIZE);
						
						//colours[image_path.getFiles()[i].getBaseName()]=get_colour(img);
						add_data(img);
						images[image_path.getFiles()[i].getBaseName()]=img;
						imageptrs.push_back(&images[image_path.getFiles()[i].getBaseName()]);
						//cerr<<image_path.getFiles()[i].getBaseName()<<": "<<colours[image_path.getFiles()[i].getBaseName()]<<endl;
						to_update.push_back(image_path.getFiles()[i].getBaseName());
						}
					}
				else {
					cerr<<"creating image path"<<endl;
					image_path.create();
				}



				//build the flann index
				Matrix<float> dataset(&data[0],data.size()/(3*FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE),3*FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE);
				index= new Index<L2<float> >(dataset, KDTreeIndexParams(4));
    			index->buildIndex();

				unlock();
			}

			cout  << "Api: " << instagram_url<<endl;

			while( isThreadRunning() != 0 ){

				
				cout<<"."<<std::flush;
			
				if (!response.open(instagram_url)) {
					cout  << "Failed to parse JSON\n" << endl;
				}
				else {	//int numImages = MIN(5,response["data"].size());
					
					
					for(int i=0; i< response["data"].size(); i++) {
						//cout  << "response " <<response["data"][i]["caption"]["id"].asString()<< endl;
						
						if (images.find(response["data"][i]["caption"]["id"].asString())==images.end()){
							std::string url = response["data"][i]["images"]["standard_resolution"]["url"].asString();
							std::string id = response["data"][i]["caption"]["id"].asString();
							cout<<"fetching "<<id<<":"<<instagram_url<<endl;
							
							ofImage img;
							img.setUseTexture(false);
							img.loadImage(url);
							if( lock() ){
								instagram_image=img;
								unlock();
							}
							img.resize(IMAGE_STORE_SIZE,IMAGE_STORE_SIZE);
							img.saveImage(ofToString(IMAGE_STORE_SIZE)+"/"+id+".png");
							img.resize(MAX_TILE_SIZE,MAX_TILE_SIZE);
							if( lock() ){
								newinstagram=true;
								colours[id]=get_colour(img);
								add_data(img);
								images[id]=img;
								imageptrs.push_back(&images[id]);
								to_update.push_back(id);
								//rebuild the flann index
								float t=ofGetElapsedTimef();
								delete index;
								Matrix<float> dataset(&data[0],data.size()/(3*FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE),3*FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE);
								index= new Index<L2<float> >(dataset, KDTreeIndexParams(4));
				    			index->buildIndex();
				    			cout<<"rebuilt flann index of "<<data.size()/(3*FLANN_MATRIX_SIZE*FLANN_MATRIX_SIZE)<<" images in "<<(ofGetElapsedTimef()-t)<<"seconds"<<endl;
								unlock();
							}
						}
					}			
				}
				
				ofSleepMillis(interval * 1000);
			}
		}

		void loadtexture(ofImage& im){
			const ofPixels& pix = im.getPixelsRef();
			im.getTextureReference().allocate(
					 pix.getWidth()
					,pix.getHeight()
					,ofGetGlInternalFormat(pix)
			);
			
			im.setUseTexture(true);
			im.update();
		}

		void update(){
			//loads one texture
			if( lock() ){
				if (to_update.size()){
					std::string im = to_update.front();

					loadtexture(images[im]);
/*
					const ofPixels& pix = images[im].getPixelsRef();
					images[im].getTextureReference().allocate(
							 pix.getWidth()
							,pix.getHeight()
							,ofGetGlInternalFormat(pix)
					);
					
					images[im].setUseTexture(true);
					images[im].update();
*/
					to_update.pop_front();

					/*
					int drawcount=0;
					for (map<string,ofImage>::iterator i=images.begin();i!=images.end();++i){
						if(i->second.isUsingTexture()){
							drawcount++;
						}
					}
					cout<<"loaded "<<im<<" "<<ofToLong(im)%(long)(ofGetWidth()-images[im].getWidth()+1)<<","<<ofToLong(im)%(long)(ofGetHeight()-images[im].getHeight()+1)<<endl;
					*/
				}
				unlock();
			}
		}

		//--------------------------
		void draw(){
			if( lock() ){
				/*
				for (map<string,ofImage>::iterator i=images.begin();i!=images.end();++i){
					if(i->second.isUsingTexture()){
						i->second.draw(ofToLong(i->first)%(long)(ofGetWidth()-i->second.getWidth()+1),ofToLong(i->first)%(long)(ofGetHeight()-i->second.getHeight()+1));
					}
				}
				*/
				map<string,ofImage>::iterator it=images.begin();
				if (it!=images.end()){
					for (int i=0;i<ofGetWidth()/MAX_TILE_SIZE;i++){
						for (int j=0;j<ofGetHeight()/MAX_TILE_SIZE;j++){
							if (it->second.isUsingTexture()){
								it->second.draw(i*MAX_TILE_SIZE,j*MAX_TILE_SIZE);
							}
							it++;
							if (it==images.end()) it=images.begin();
						}
					}
				}
				unlock();
			}
		}


};