// Copyright (c) 1999-2005
// Motorola, Inc., ALL RIGHTS RESERVED


#include <assert.h>
#include <string.h>
#include <iostream>
#include <stdexcept>
#include <sstream>
#include <fstream>

#include <sys/types.h>
#include <sys/stat.h>
#include <memory.h>

using namespace std;

#ifdef __GNUG__
    #define COPY(value) strdup(value)
    #include <unistd.h>
    #include <pthread.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <errno.h>
    
    // cairo
    #include <png.h>
    #include <cairo.h>
    #include <svg-cairo.h>
    // cairo

    #include <linux/types.h>

#else 
    #define COPY(value) _strdup(value)
    #include <process.h>
#endif


static bool isActive;

struct NavMapImage {
        char* data;/*!<pointer to the image data. */
        long size; /*!<number of bytes of the image data. */
};

class CairoTest {

public:
	
    CairoTest(int n) : nTds(n) {
        isActive = false;
        source.data = NULL;
    };
    ~CairoTest() {
        if (source.data!=NULL) {
            delete [] source.data;
        }
    }
    bool loadFile(const char *file);
    void Run();
    void RunTests(int Id);

private:
    
    int nTds;
    char *inp_file;  
    NavMapImage source;
};

///////////////////////////////////////////////////////

#ifdef __GNUG__

# define CAIRO_MUTEX_DECLARE(name) static pthread_mutex_t name = PTHREAD_MUTEX_INITIALIZER
# define CAIRO_MUTEX_LOCK(name) pthread_mutex_lock (&name)
# define CAIRO_MUTEX_UNLOCK(name) pthread_mutex_unlock (&name)

#define MIN(a, b)     (((a) < (b)) ? (a) : (b))
// Number of bytes per pixel for image in Cairo
#define CAIRO_BPP 4
// Number of bytes per pixel for image in PNG
#define PNG_BPP 4

static void
write_data_fn(png_struct* png_ptr, png_byte * data,unsigned int length) {

    NavMapImage *img = (NavMapImage*) png_get_io_ptr(png_ptr);
    memcpy((img->data)+(img->size), data, length);
    img->size += length;
    
}

// Really never called
static void
flush_data_fn(png_struct* png_ptr) {
    // nothing to do
}

static void
unpremultiply_data (png_structp png, png_row_infop row_info, png_bytep data){
    int i;

    for (i = 0; i < row_info->rowbytes; i += 4) {
        unsigned char *b = &data[i];
        unsigned int pixel;
        unsigned char alpha;

	    memcpy (&pixel, b, sizeof (unsigned int));
	    alpha = (pixel & 0xff000000) >> 24;
        if (alpha == 0) {
	        b[0] = b[1] = b[2] = b[3] = 0;
	    } else {
            b[0] = (((pixel & 0x0000ff) >>  0) * 255 + alpha / 2) / alpha;
            b[1] = (((pixel & 0x00ff00) >>  8) * 255 + alpha / 2) / alpha;
            b[2] = (((pixel & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
	        b[3] = alpha;
	    }
    }
}


void write_png(char * buffer, int width, int height, NavMapImage *target) {

    int i;
    png_struct *png;
    png_info *info;
    png_byte **rows;
    png_color_16 white;
    int stride = PNG_BPP * width;
    
    rows =(png_byte**) malloc (height * sizeof(png_byte*));

    for (i = 0; i < height; i++) {
	    rows[i] = (png_byte*) buffer + i * stride;
    }

    png = png_create_write_struct (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    info = png_create_info_struct (png);

    NavMapImage image;

    image.size = 0;

    // draft buffer size estimation (we don't know final size yet)
    // suppose to be not more than 16 byte per pixel
    
    int iMaxSize = 16*width*height;
    image.data = new char [iMaxSize];

    // set custom I/O functions
    png_set_write_fn(png,(png_voidp)  &image, write_data_fn, flush_data_fn);


    png_set_IHDR (png, info,
		  width, height, 8,
		  PNG_COLOR_TYPE_RGB_ALPHA, 
		  PNG_INTERLACE_NONE,
		  PNG_COMPRESSION_TYPE_DEFAULT,
		  PNG_FILTER_TYPE_DEFAULT);

    white.red = 0xff;
    white.blue = 0xff;
    white.green = 0xff;
    png_set_bKGD (png, info, &white);

    png_set_write_user_transform_fn (png, unpremultiply_data);
    png_set_bgr (png);
    png_write_info (png, info);
    png_write_image (png, rows);
    png_write_end (png, info);
    png_destroy_write_struct (&png, &info);

    free (rows);
    
    // prevent buffer overflow
    int size = ((image.size < iMaxSize) ? image.size : iMaxSize);

    target->data = new char [size];
    
    memcpy(target->data, image.data, size);
    
    target->size = size;

    delete [] image.data;
}

void svg2image(NavMapImage *src, NavMapImage *target, cairo_format_t format, 
               void (*write_fn)(char * buffer, int width, int height, NavMapImage *target)
               ){
    unsigned int svg_width, svg_height;


    //CAIRO_MUTEX_DECLARE(my_cairo_mutex);
    
    svg_cairo_status_t status;
    cairo_t *cr;
    svg_cairo_t *svgc;
    cairo_surface_t *surface;

    status = svg_cairo_create (&svgc);

    if (status) {
	    fprintf (stderr, "Failed to create svg_cairo_t. Exiting.\n");
	    return;
    }

        status = svg_cairo_parse_buffer(svgc, src->data, src->size);
        if (status)
	        return;

        svg_cairo_get_size (svgc, &svg_width, &svg_height);
        int stride;

        switch(format) {
            case CAIRO_FORMAT_A1:
                stride = svg_width / 8;
                break;
            case CAIRO_FORMAT_A8:
                stride = svg_width;
                break;
            case CAIRO_FORMAT_RGB24:
            case CAIRO_FORMAT_ARGB32:
            default:
                stride = CAIRO_BPP * svg_width;
        }   

        char * image_buf = (char *) malloc (stride * svg_height);

        surface = cairo_image_surface_create_for_data ((unsigned char *) image_buf, format, svg_width, svg_height, stride);
            cr = cairo_create (surface);
  
            /// XXX: This probably doesn't need to be here (eventually) 
                cairo_set_source_rgb (cr, 1, 1, 1);

               // CAIRO_MUTEX_LOCK(my_cairo_mutex);
                    status = svg_cairo_render (svgc, cr);
               // CAIRO_MUTEX_UNLOCK(my_cairo_mutex);

            cairo_destroy (cr);
        
        cairo_surface_destroy(surface);

    svg_cairo_destroy (svgc);
   
     // call function to write image to corresponding format
    (*write_fn) (image_buf, svg_width, svg_height, target);

    free (image_buf);
}



void svg2png(NavMapImage *src, NavMapImage *target) {

    svg2image(src, target, CAIRO_FORMAT_ARGB32, write_png);

}

     
#else
// stub
void svg2png(NavMapImage *src, NavMapImage *target) {

}
  
#endif
/////////////////////////////////////////////////////////


void CairoTest::RunTests(int Id) {
    NavMapImage target;
    target.data = NULL;
    char file[80];
    sprintf(file, "%d.png", Id);
    svg2png(&source, &target);

////////////////////
    
    std::ofstream f;

    cerr<<"***writing PNG file:"<<file<<"\n"; 
    f.open(file,ios::out);
    if(!f.is_open()){
        cerr<<"***fail on openning file:"<<file<<"\n";
        return;
    }
    
    f.write(target.data, target.size);
    
    f.close();
    
////////////////////
    if(target.data !=NULL) delete [] target.data;

    cerr << "Conversion completed in thread" << Id << endl;
}

#ifdef __GNUG__
void* MyThreadProc(void* parameter) {
    int Id =pthread_self();
    cout <<"Started thread " <<Id<< endl;

    CairoTest *test = (CairoTest*) parameter;

    isActive = true;
    
    while(true)        
        test->RunTests(Id);
    isActive = false;
    
    cout <<"Finished thread " <<Id<< endl;
    return NULL;
}
#endif

void CairoTest::Run() {
#ifdef __GNUG__
    
        pthread_t tid = 0;
        // start several threads
        for(int i=0; i<nTds; i++) {
            pthread_create(&tid, NULL,MyThreadProc, this);
        }
        // wait until all threads completed
        while (true) {
            sleep(10 /*00*/);
        }
        
#endif
}
int main( int argc, char *argv[ ] ) {

	char * in_file;
	if (argc<2) {
		cerr << "No arguments was specified \n Format is: \n"
			<< "ConReq.exe <SVG_file> [<Num_of_treads = 1> ]\n";
			return -1;
	}
	else in_file = argv[1];
    int nThreads = 1;
    if(argc >2) {
        nThreads = atoi(argv[2]);
    }

	CairoTest test(nThreads);
    
    if (test.loadFile(in_file)) {
          test.Run();
    }

	
	return 0;
}

bool CairoTest::loadFile(const char *file){

    std::ifstream f;

    struct stat st;

    if(stat(file, &st)!=0) {
        cerr<<"***fail on openning file:"<<file<<"\n";
        return false;
    }


    cerr<<"***loading SVG file:"<<file<<"\n"; 
    f.open(file,ios::in);
    if(!f.is_open()){
        cerr<<"***fail on openning file:"<<file<<"\n";
        return false;
    }


    int size = st.st_size;
        
    source.size = size;
    source.data = new char [size];
    
    f.read(source.data, size);
    
    f.close();
   
	return true;

}