/*
 * Copyright 2002-2008 Guillaume Cottenceau, 2015 Aleksander Denisiuk
 *
 * This software may be freely redistributed under the terms
 * of the X11 license.
 *
 */

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>

#define PNG_DEBUG 3
#include <png.h>


#define OUT_FILE "initials.png"
#define WIDTH 600
#define HEIGHT 600
#define COLOR_TYPE PNG_COLOR_TYPE_RGB
#define BIT_DEPTH 8


void abort_(const char * s, ...)
{
	va_list args;
	va_start(args, s);
	vfprintf(stderr, s, args);
	fprintf(stderr, "\n");
	va_end(args);
	abort();
}

int x, y;

int width, height;
png_byte color_type;
png_byte bit_depth;

png_structp png_ptr;
png_infop info_ptr;
int number_of_passes;
png_bytep * row_pointers;

void create_png_file()
{
	width = WIDTH;
	height = HEIGHT;
        bit_depth = BIT_DEPTH;
        color_type = COLOR_TYPE;

	row_pointers = (png_bytep*) malloc(sizeof(png_bytep) * height);
	for (y=0; y<height; y++)
		row_pointers[y] = (png_byte*) malloc(width*bit_depth*3);


}


void write_png_file(char* file_name)
{
	/* create file */
	FILE *fp = fopen(file_name, "wb");
	if (!fp)
		abort_("[write_png_file] File %s could not be opened for writing", file_name);


	/* initialize stuff */
	png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
	
	if (!png_ptr)
		abort_("[write_png_file] png_create_write_struct failed");

	info_ptr = png_create_info_struct(png_ptr);
	if (!info_ptr)
		abort_("[write_png_file] png_create_info_struct failed");

	if (setjmp(png_jmpbuf(png_ptr)))
		abort_("[write_png_file] Error during init_io");

	png_init_io(png_ptr, fp);


	/* write header */
	if (setjmp(png_jmpbuf(png_ptr)))
		abort_("[write_png_file] Error during writing header");

	png_set_IHDR(png_ptr, info_ptr, width, height,
		     bit_depth, color_type, PNG_INTERLACE_NONE,
		     PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);

	png_write_info(png_ptr, info_ptr);


	/* write bytes */
	if (setjmp(png_jmpbuf(png_ptr)))
		abort_("[write_png_file] Error during writing bytes");

	png_write_image(png_ptr, row_pointers);


	/* end write */
	if (setjmp(png_jmpbuf(png_ptr)))
		abort_("[write_png_file] Error during end of write");

	png_write_end(png_ptr, NULL);

        /* cleanup heap allocation */
	for (y=0; y<height; y++)
		free(row_pointers[y]);
	free(row_pointers);

        fclose(fp);
}

void write_pixel(int x, int y,
				png_byte cr, png_byte cg, png_byte cb){
	png_byte* row = row_pointers[y];
	png_byte* ptr = &(row[x*3]);
	ptr[0] = cr;
	ptr[1] = cg;
	ptr[2] = cb;
}

void bresenham(int i1, int j1, int i2, int j2,
				png_byte cr, png_byte cg, png_byte cb){
	int m, b, j, P, i;
	if(i2>i1 && j2>=j1 && j2-j1<=i2-i1){
		printf("pierwszy\n");
		m = 2*(j2-j1);
		b = 0;
		write_pixel(i1, j1, cr, cg, cb);
		j = j1;
		P = i2-i1;
		for(i=i1+1; i<=i2; i++){
			b+=m;
			if(b>P){
				j=j+1;
				b=b-2*P;
			}
			write_pixel(i, j, cr, cg, cb);
		}
	}
	else if(i2>i1 && -j2>=-j1 && -j2+j1<=i2-i1){
		printf("drugi\n");
		m = 2*(j2-j1);
		b = 0;
		write_pixel(i1, j1, cr, cg, cb);
		j = j1;
		P = i2-i1;
		for(i=i1+1; i<=i2; i++){
			b+=m;
			if(b>P){
				j=j-1;
				b=b-2*P;
			}
			write_pixel(i, j, cr, cg, cb);
		}
	}
	else if(j2>j1 && i2>=i1 && i2-i1<=j2-j1){
		printf("trzeci\n");
		m = 2*(i2-i1);
		b = 0;
		write_pixel(i1, j1, cr, cg, cb);
		i = i1;
		P = j2-j1;
		for(j=j1+1; j<=j2; j++){
			b+=m;
			if(b>P){
				i=i+1;
				b=b-2*P;
			}
			write_pixel(i, j, cr, cg, cb);
		}
	}
	else if(-j2>-j1 && i2>=i1 && i2-i1<=-j2+j1){
		printf("czwarty\n");
		m = 2*(i2-i1);
		b = 0;
		write_pixel(i1, j1, cr, cg, cb);
		i = i1;
		P = j1-j2;
		for(j=j1-1; j>=j2; j--){
			b+=m;
			if(b>P){
				i=i+1;
				b=b-2*P;
			}
			write_pixel(i, j, cr, cg, cb);
		}
	}
	else
		printf("Tak sie nie robi\n");
}

void write8pixel(int x, int y,
				png_byte cr, png_byte cg, png_byte cb){
	write_pixel(x+WIDTH/2, y+HEIGHT/2, cr, cg, cb);
	write_pixel(-x+WIDTH/2, y+HEIGHT/2, cr, cg, cb);
	write_pixel(x+WIDTH/2, -y+HEIGHT/2, cr, cg, cb);
	write_pixel(-x+WIDTH/2, -y+HEIGHT/2, cr, cg, cb);
	write_pixel(y+WIDTH/2, x+HEIGHT/2, cr, cg, cb);
	write_pixel(-y+WIDTH/2, x+HEIGHT/2, cr, cg, cb);
	write_pixel(y+WIDTH/2, -x+HEIGHT/2, cr, cg, cb);
	write_pixel(-y+WIDTH/2, -x+HEIGHT/2, cr, cg, cb);
}

void circle(int r,
			png_byte cr, png_byte cg, png_byte cb){
	int i,j,f;
	i = 0; j = r; f = 5-4*r;
	write8pixel(i,j,cr,cg,cb);
	while(i<j){
		if(f>0){
			f = f+8*i-8*j+20;
			j=j-1;
		}
		else{
			f = f+8*i+12;
		}
		i=i+1;
		write8pixel(i,j,cr,cg,cb);
	}
}

void write_P(int x, int y,
			png_byte cr, png_byte cg, png_byte cb){
	//gora
    bresenham(x, y, x+80, y, cr, cg, cb);  					// _
    bresenham(x+80, y, x+120, y+40, cr, cg, cb);  			//  \ 		//
    bresenham(x+120, y+40, x+120, y+150, cr, cg, cb); 		//  | 
    bresenham(x+30, y+150, x+120, y+150, cr, cg, cb);  		// _
	//pionowa linia
    bresenham(x+30, y+150, x+30, y+270, cr, cg, cb);  		//   |
    bresenham(x, y, x, y+270, cr, cg, cb);  				// |
    bresenham(x, y+270, x+30, y+270, cr, cg, cb);  			//  _
	//srodek
    bresenham(x+30, y+30, x+70, y+30, cr, cg, cb);  		//  _
    bresenham(x+70, y+30, x+90, y+50, cr, cg, cb);  		//   \ 		//
    bresenham(x+90, y+50, x+90, y+120, cr, cg, cb);  		//   |
    bresenham(x+30, y+120, x+90, y+120, cr, cg, cb);  		//  _
    bresenham(x+30, y+30, x+30, y+120, cr, cg, cb);  		// |
}

void write_K(int x, int y,
			png_byte cr, png_byte cg, png_byte cb){
	
	//pionowa linia
    bresenham(x, y, x+30, y, cr, cg, cb);  					//  _
    bresenham(x, y, x, y+270, cr, cg, cb);  				// |
    bresenham(x+30, y, x+30, y+120, cr, cg, cb);  			//   |
    bresenham(x+30, y+150, x+30, y+270, cr, cg, cb);  		//   |
    bresenham(x, y+270, x+30, y+270, cr, cg, cb);  			//  _
	
	//gorna linia
    bresenham(x+130, y, x+160, y, cr, cg, cb);  			//  _
    bresenham(x+30, y+120, x+130, y, cr, cg, cb);  			// /
    bresenham(x+45, y+135, x+160, y, cr, cg, cb);  			//  /
	
	//dolna linia
    bresenham(x+45, y+135, x+160, y+270, cr, cg, cb);  			//  \		//
    bresenham(x+30, y+150, x+130, y+270, cr, cg, cb);  			// \		//
    bresenham(x+130, y+270, x+160, y+270, cr, cg, cb);  			//  _
}

void fill_color(int x, int y,
          png_byte cr, png_byte cg, png_byte cb,
		  png_byte br, png_byte bg, png_byte bb){
    if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT)
        return;

    int stos_x[WIDTH * HEIGHT];
    int stos_y[WIDTH * HEIGHT];
    int top = 0;

    stos_x[top] = x;
    stos_y[top] = y;
    top++;

    while (top > 0) {
        top--;
        x = stos_x[top];
        y = stos_y[top];

        if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT)
            continue;

        png_byte* row = row_pointers[y];
        png_byte* ptr = &(row[x * 3]);

        if (!(ptr[0] == br && ptr[1] == bg && ptr[2] == bb))
            continue;

        ptr[0] = cr;
        ptr[1] = cg;
        ptr[2] = cb;
		
		stos_x[top] = x + 1; stos_y[top] = y; top++;
		stos_x[top] = x - 1; stos_y[top] = y; top++;
		stos_x[top] = x;     stos_y[top] = y + 1; top++;
		stos_x[top] = x;     stos_y[top] = y - 1; top++;
    }
}

void fill(int x, int y,
          png_byte cr, png_byte cg, png_byte cb){
	
    png_byte* row = row_pointers[y];
    png_byte* ptr = &(row[x * 3]);
	
	int br = ptr[0];
	int bg = ptr[1];
	int bb = ptr[2];
	fill_color(x,y,cr,cg,cb,br,bg,bb);
}

void process_file(void)
{
	for (y=0; y<height; y++) {
		png_byte* row = row_pointers[y];
		for (x=0; x<width; x++) {
			png_byte* ptr = &(row[x*3]);
			ptr[0] = 0;
			ptr[1] = ptr[2] = 255;
		}
	}

	circle(250, 0, 0, 0);
	fill(300,300,255,255,0);
	
	write_P(150,180,0,0,0);
	fill(151,181,255,0,0);
	
	write_K(300,180,0,0,0);
	fill(301,181,255,0,0);
}


int main(int argc, char **argv)
{
	create_png_file();
	process_file();
	write_png_file(OUT_FILE);

        return 0;
}