// OMERO_C++_Test.cpp : Defines the entry point for the console application.
//

// Domain
#include <omero/client.h>
#include <omero/model/Experimenter.h>
#include <omero/model/Project.h>
#include <omero/model/Dataset.h>
#include <omero/model/ImageI.h>
#include <omero/model/Pixels.h>
#include <omero/api/Gateway.h>
#include <omero/api/RawPixelsStore.h>
#include <omero/api/IPixels.h>

// Std
#include <stdio.h>
#include <iostream>
#include <cassert>
#include <vector>
#include <time.h>
#include <map>

using namespace std;

int main(int argc, char* argv[])
{
	long pixId = 1;

	//cout<<"Hello World\n"<<endl;
	omero::client_ptr omero; 
	omero::api::ServiceFactoryPrx sf;
	omero::api::IPixelsPrx pixelsService;
	omero::api::GatewayPrx gateway;
	omero::model::PixelsPtr pixelsObject;

	omero = new omero::client("localhost", 4063);

	try
	{
		sf = omero->createSession("root", "omero");
	}
	catch (const Glacier2::CannotCreateSessionException& ccse) 
	{
		printf("ERROR: omero->createSession();\n");
	}

	try
	{
		pixelsService = sf->getPixelsService();
	}
	catch (const omero::ServerError& serverError) 
	{
		printf("ERROR: %s\n", serverError.message);
		printf("ERROR: sf->getPixelsService();\n");
	}
	catch (const Ice::LocalException& localException)
	{
		localException.ice_print(cout);
		printf("\nERROR: sf->getPixelsService();\n");
	}

	try 
	{
		gateway = sf->createGateway();
	}
	catch (const omero::ServerError& serverError) 
	{
		printf("ERROR: %s\n", serverError.message);
		printf("ERROR: sf->createGateway();\n");
	} 
	catch (const Ice::LocalException& localException)
	{
		localException.ice_print(cout);
		printf("\nERROR: sf->createGateway();\n");
	}

	/*try 
	{
		omero::model::ImagePtr img = gateway->getImage(pixId);
	}
	catch (const omero::ServerError& serverError) 
	{
		printf("ERROR: %s\n", serverError.message);
		printf("ERROR: gateway->getImage();\n");
	}
	catch (const Ice::LocalException& localException)
	{
		localException.ice_print(cout);
		printf("\nERROR: gateway->getImage();\n");
	}*/

	try 
	{
		pixelsObject = gateway->getPixels(pixId);
	}
	catch (const omero::ServerError& serverError) 
	{
		printf("ERROR: %s\n", serverError.message);
		printf("ERROR: gateway->getPixels();\n");
	}
	catch (const Ice::LocalException& localException)
	{
		localException.ice_print(cout);
		printf("\nERROR: gateway->getPixels();\n");
	}

	if (!pixelsObject) 
	{
		// is null
		printf("ERROR: pixelsObject is NULL!\n");
	}

	omero::api::RawPixelsStorePrx rawPixelsStore = sf->createRawPixelsStore();
	rawPixelsStore->setPixelsId(pixId, false);

	omero::api::ServiceList services;
	services.push_back(rawPixelsStore);
	services.push_back(pixelsService);
	sf->keepAllAlive(services);

	int xdim = pixelsObject->getSizeX()->getValue();
    int ydim = pixelsObject->getSizeY()->getValue();
    int zdim = pixelsObject->getSizeZ()->getValue();
    cout << "The image " << pixId << " is: " << xdim << "x" << ydim << "x" << zdim << endl;

    int cdim = pixelsObject->getSizeC()->getValue();
    int tdim = pixelsObject->getSizeT()->getValue();
    cout << "The image " << pixId << " has: " << cdim << " colors and " << tdim << " timesteps" << endl;

	double xphysize = pixelsObject->getPhysicalSizeX()->getValue();
	double yphysize = pixelsObject->getPhysicalSizeY()->getValue();
	double zphysize = pixelsObject->getPhysicalSizeZ()->getValue();
    
	cout << "Physical Size x: " << xphysize << " y: " << yphysize << " z: " << zphysize << endl;

	for(int z=0; z<zdim; z++)
	{
		printf("z: %d of %d\n", z, zdim);

		for(int c=0; c<cdim; c++)
		{
			for(int t=0; t<tdim; t++)
			{
				Ice::ByteSeq pixs = rawPixelsStore->getPlane(z,c,t);
				
				for(int x=0; x<xdim; x++)
				{
					for(int y=0; y<ydim; y++)
					{
						int index = y*xdim+x;
						//printf("pixs[i] %d\n", (int)pixs[index]);
					}
				}
			}
		}
	}

	omero->closeSession();
	system("pause");
	return 0;
}