//----------------------------------------------------------------------------------------------------------------
// Class definition include
//----------------------------------------------------------------------------------------------------------------

#include "wxContourGUIExample.h"
#include "wxContourMainFrame.h"
//#include "OutlineModelManager.h"
//#include "wxContourEventHandler.h"

#include <creaImageIOWxGimmickDialog.h>

#include <creaVtkBasicSlicer.h>
//#include "wxContourMainPanel.h"

#include "vtkMetaImageReader.h"
#include <map>
#include "vtkImageData.h"

#include "wx/artprov.h"
#include <wx/filedlg.h>
//#include "OutlineModelBuilder.h"
//#include "ContourThing.h"
//#include "AxeThing.h"
//#include "ImageSourceThing.h"
//#include "ImageSectionThing.h"
//#include "SomeEnvironment.h"
//#include "ReaderEnvironment.h"

//#include "interfMainPanel.h"

#if defined(MACOSX) // assume this is OSX 
# include <sys/param.h>
# include <mach-o/dyld.h> // _NSGetExecutablePath : must add -framework CoreFoundation to link line 
# include <string.h>
# ifndef PATH_MAX
#  define PATH_MAX MAXPATHLEN
# endif
#endif // MACOSX

#ifndef PATH_MAX // If not defined yet : do it 
#  define PATH_MAX 2048
#endif

#if defined(WIN32)
  #include <direct.h>
#else
   #include <dirent.h>  
#endif

#include <stdlib.h>

wxContourMainFrame* wxTheApplication::frame = 0;

//----------------------------------------------------------------------------------------------------------------
// This macro implements the entry point (main function) for the application
//----------------------------------------------------------------------------------------------------------------

/*
//EED
// http://lists.wxwidgets.org/archive/wx-dev/msg30449.html
wxString GetExecutablePath()
{
    char buf[512];
    char* slash;

#if defined(WIN32)
    GetModuleFileName(NULL, buf, 511);
    slash = strrchr(buf, '\\');
    if (slash)
    {
        *slash = 0;
    }
#elif defined(__LINUX__)
    int res;
    res = readlink("/proc/self/exe", buf, 512);
    if (res == -1)
        return _T("");
    buf[res] = 0;
    slash = strrchr(buf, '/');
    if (slash)
    {
        *slash = 0;
    }
#else
    return "";
#endif

    return wxString(buf, wxConvUTF8 );
}
*/

//=========================================================================  
// From http://www.fltk.org/newsgroups.php?gfltk.general+v:22083
//
int get_app_path (char *pname, size_t pathsize)
{
#ifdef LINUX	
    /* Oddly, the readlink(2) man page says no NULL is appended. */
    /* So you have to do it yourself, based on the return value: */
    pathsize --; /* Preserve a space to add the trailing NULL */
    long result = readlink("/proc/self/exe", pname, pathsize);
    if (result > 0)
	{
		pname[result] = 0; /* add the #@!%ing NULL */
		
		if ((access(pname, 0) == 0))
			return 0; /* file exists, return OK */
		/*else name doesn't seem to exist, return FAIL (falls
		 through) */
	}
#endif /* LINUX */
    
#ifdef WIN32
    long result = GetModuleFileName(NULL, pname, pathsize);
    if (result > 0)
	{
		/* fix up the dir slashes... */
		int len = strlen(pname);
		int idx;
		for (idx = 0; idx < len; idx++)
		{
			if (pname[idx] == '\\') pname[idx] = '/';
		}
		
		for (idx = len-1; idx >=0 ; idx--)
		{
			if (pname[idx] == '/')
			{ 
				pname[idx+1] = '\0';
				idx = -1;
			}
		}
		
		if ((access(pname, 0) == 0))
			return 0; /* file exists, return OK */
		/*else name doesn't seem to exist, return FAIL (falls
		 through) */
	}
#endif /* WIN32 */
    
#ifdef SOLARIS
    char *p = getexecname();
    if (p)
	{
		/* According to the Sun manpages, getexecname will
		 "normally" return an */
		/* absolute path - BUT might not... AND that IF it is not,
		 pre-pending */
		/* getcwd() will "usually" be the correct thing... Urgh!
		 */
		
		/* check pathname is absolute (begins with a / ???) */
		if (p[0] == '/') /* assume this means we have an
		 absolute path */
		{
			strncpy(pname, p, pathsize);
			if ((access(pname, 0) == 0))
				return 0; /* file exists, return OK */
		}
		else /* if not, prepend getcwd() then check if file
		 exists */
		{
			getcwd(pname, pathsize);
			long result = strlen(pname);
			strncat(pname, "/", (pathsize - result));
			result ++;
			strncat(pname, p, (pathsize - result));
			
			if ((access(pname, 0) == 0))
				return 0; /* file exists, return OK */
			/*else name doesn't seem to exist, return FAIL
			 (falls through) */
		}
	}
#endif /* SOLARIS */
    
#ifdef MACOSX /* assume this is OSX */
    /*
	 from http://www.hmug.org/man/3/NSModule.html
	 
	 extern int _NSGetExecutablePath(char *buf, unsigned long
	 *bufsize);
	 
	 _NSGetExecutablePath  copies  the  path  of the executable
	 into the buffer and returns 0 if the path was successfully
	 copied  in the provided buffer. If the buffer is not large
	 enough, -1 is returned and the  expected  buffer  size  is
	 copied  in  *bufsize.  Note that _NSGetExecutablePath will
	 return "a path" to the executable not a "real path" to the
	 executable.  That  is  the path may be a symbolic link and
	 not the real file. And with  deep  directories  the  total
	 bufsize needed could be more than MAXPATHLEN.
	 */
	
    int status = -1;
    char *given_path = (char*)malloc(MAXPATHLEN * 2);
    if (!given_path) return status;
    
    uint32_t npathsize = MAXPATHLEN * 2;
    long result = _NSGetExecutablePath(given_path, &npathsize);
    if (result == 0)
	{ /* OK, we got something - now try and resolve the real path...
	 */
		if (realpath(given_path, pname) != NULL)
		{
			if ((access(pname, 0) == 0))
				status = 0; /* file exists, return OK */
		}
	}
    free (given_path);
    return status;
#endif /* MACOSX */
    
    return -1; /* Path Lookup Failed */
} 
//=========================================================================

#if defined(_WIN32)
#define CREACONTOUR_VALID_FILE_SEPARATOR_CHAR '\\'
#else
#define CREACONTOUR_VALID_FILE_SEPARATOR_CHAR '/'
#endif

//=========================================================================
std::string GetExecutablePath()
{
    char name[PATH_MAX];
    int err = get_app_path(name, PATH_MAX);
    if (err) 
	{
		printf("Could not determine current executable path ?  ");  
	}
    
    // remove the exe name
    char *slash;		
    slash = strrchr(name, CREACONTOUR_VALID_FILE_SEPARATOR_CHAR);
    if (slash)
	{
		*slash = 0;
	}
    return name;
}

//=========================================================================
//=========================================================================
IMPLEMENT_APP( wxTheApplication );
/*
wxContourGUIExample :: wxContourGUIExample(const wxString& title, const wxPoint& pos, const wxSize& size)
: wxFrame((wxFrame *) NULL, -1, title, pos, size)
{
}
*/

#ifdef _DEBUG
void wxAppConsole::OnAssert(char const *,int,char const *,char const *)
{
}

void wxAppConsole::OnAssertFailure(char const *,int,char const *,char const *,char const *)
{
}
#endif

bool wxTheApplication :: OnInit()
{
	wxInitAllImageHandlers();

   int image_type = GIMMICK_3D_IMAGE_SELECTION;
   int threads = 1;

   creaImageIO::WxGimmickDialog w(0,
				  -1,
				  _T("WxGimmickDialog test"),
				  wxDefaultPosition,
				  wxSize(1200,800),
				  image_type,
				  threads);
   w.ShowModal();

	std::string datadir(  GetExecutablePath() ) ;
	
#ifdef MACOSX /* assume this is OSX */
	datadir=datadir+"/../../..";
#endif // MACOSX	
	
   //vtkImageData* selectedimage=NULL;
   std::vector<vtkImageData*> images;
	if(w.GetReturnCode() == wxID_OK){

       std::vector<std::string> s;
       w.GetSelectedFiles(s);
       std::vector<std::string>::iterator i;
	   for (i=s.begin();i!=s.end();++i){
		   std::cout << *i << std::endl;
	   }
	   	
	   std::cout << "$$$$ "<<std::endl;
       w.GetSelectedImages(images);
	   //selectedimage = images[0];
       //crea::VtkBasicSlicer(images.front());
       //images.front()->Delete();

	}else if (w.GetReturnCode() == wxID_CANCEL){
	   vtkMetaImageReader *reader = vtkMetaImageReader::New();
		std::string filename= datadir + "/data/hola.mhd";   	   
	   reader->SetFileName( filename.c_str() );
	   reader->Update();
	   images.push_back(reader->GetOutput());
  	}else{        
		return -1;
	}   

	wxFrame* frame1 = new wxFrame(NULL, wxID_ANY, wxT("ROI Application  -    Evaluation version, 09 Feb 2009 "), wxPoint(400,50), wxSize(800, 600) );

	//frame = new wxContourMainFrame( frame1, wxID_ANY, wxString(_T("")), wxPoint(50,50), wxSize(800, 600), images ); 
	frame = wxContourMainFrame::getInstance(frame1, wxID_ANY, wxString(_T("")), wxPoint(200,50), wxSize(800, 600), images,  wxDEFAULT_FRAME_STYLE | wxSUNKEN_BORDER,datadir );
	frame1->CreateStatusBar();
	frame1->Show(TRUE);
    frame->RefreshInterface();
	return TRUE;
}

#if(WIN32)
int main(int argc, char* argv[])					
  {									
    return WinMain(::GetModuleHandle(NULL), NULL,			
		   ::GetCommandLine(), SW_SHOWNORMAL);			
  }		
#else
#endif