// ==============================================================
//	This file is part of Glest Shared Library (www.glest.org)
//
//	Copyright (C) 2001-2010 Martiño Figueroa and others
//
//	You can redistribute this code and/or modify it under
//	the terms of the GNU General Public License as published
//	by the Free Software Foundation; either version 2 of the
//	License, or (at your option) any later version
// ==============================================================

#include "JPGReader.h"
#include "FileReader.h"

#include "data_types.h"
#include "pixmap.h"
#include <stdexcept>
#include <jpeglib.h>
#include <setjmp.h>

#include "util.h"
#include "leak_dumper.h"

using std::runtime_error;
using std::ios;

namespace Shared {
	namespace Graphics {

		// =====================================================
		//	Methods used for JPG-Decompression
		// =====================================================


		//Methods used by jpeglib
		static void init_source(j_decompress_ptr cinfo) {
			//It already is initialized
		}
		static boolean fill_input_buffer(j_decompress_ptr cinfo) {
			//it is already filled
			return boolean(true);
		}
		static void skip_input_data(j_decompress_ptr cinfo, long num_bytes) {
			if (num_bytes > 0) {
				jpeg_source_mgr* This = cinfo->src;
				This->bytes_in_buffer -= num_bytes;
				This->next_input_byte += num_bytes;
			}
		}
		static void term_source(j_decompress_ptr cinfo) {
		}

		// =====================================================
		//	class JPGReader
		// =====================================================

		/**Return an array containing the used extensions,
		  * initialized*/
		  //static inline const string* getExtensions() {
			  //static const string extensions[] = {"jpg", "jpeg", ""};
		static inline std::vector<string> getExtensions() {
			static std::vector<string> extensions;
			if (extensions.empty() == true) {
				extensions.push_back("jpg");
				extensions.push_back("jpeg");
			}

			return extensions;
		}

		JPGReader::JPGReader() : FileReader<Pixmap2D>(getExtensions()) {
		}

		Pixmap2D* JPGReader::read(ifstream& is, const string& path, Pixmap2D* ret) const {
			if (GlobalStaticFlags::getIsNonGraphicalModeEnabled() == true) {
				throw megaglest_runtime_error("Loading graphics in headless server mode not allowed!");
			}

			//Read file
			is.seekg(0, ios::end);
			streampos length = is.tellg();
			if (length < 8) {
				return NULL;
			}
			is.seekg(0, ios::beg);
			uint8 *buffer = new uint8[(unsigned int) length];
			is.read((char*) buffer, (std::streamsize)length);
			static bool bigEndianSystem = Shared::PlatformByteOrder::isBigEndian();
			if (bigEndianSystem == true) {
				Shared::PlatformByteOrder::fromEndianTypeArray<uint8>(buffer, (size_t) length);
			}
			if (length < 2) {
				throw megaglest_runtime_error("length < 2", true);
			}
			//Check buffer (weak jpeg check)
			//if (buffer[0] != 0x46 || buffer[1] != 0xA0) {
			// Proper header check found from: http://www.fastgraph.com/help/jpeg_header_format.html
			if (buffer[0] != 0xFF || buffer[1] != 0xD8) {
				std::cout << "0 = [" << std::hex << (int) buffer[0] << "] 1 = [" << std::hex << (int) buffer[1] << "]" << std::endl;
				delete[] buffer;
				throw megaglest_runtime_error(path + " is not a jpeg", true);
			}

			struct jpeg_decompress_struct cinfo;
			struct jpeg_error_mgr jerr;

			JSAMPROW row_pointer[1];
			row_pointer[0] = NULL;
			cinfo.err = jpeg_std_error(&jerr); //Standard error handler
			jpeg_create_decompress(&cinfo); //Create decompressing structure
			struct jpeg_source_mgr source;

			jmp_buf error_buffer; //Used for saving/restoring context
			// Set up data pointer
			source.bytes_in_buffer = (size_t) length;
			source.next_input_byte = (JOCTET*) buffer;
			cinfo.src = &source;

			if (setjmp(error_buffer)) { //Longjump was called --> an exception was thrown
				delete[] buffer;
				jpeg_destroy_decompress(&cinfo);
				if (row_pointer[0] != NULL) {
					delete[] row_pointer[0];
				}
				throw megaglest_runtime_error(path + " is a corrupt(1) jpeg", true);
			}

			source.init_source = init_source;
			source.fill_input_buffer = fill_input_buffer;
			source.resync_to_restart = jpeg_resync_to_restart;
			source.skip_input_data = skip_input_data;
			source.term_source = term_source;

			/* reading the image header which contains image information */
			if (jpeg_read_header(&cinfo, TRUE) != JPEG_HEADER_OK) {
				delete[] buffer;
				jpeg_destroy_decompress(&cinfo);
				throw megaglest_runtime_error(path + " is a corrupt(1) jpeg", true);
			}


			/*std::cout << "JPEG FILE Information: " << std::endl;
			std::cout << "Image width and height: " << cinfo.image_width <<" pixels and " << cinfo.image_height <<" pixels." << std::endl;

			std::cout << "Color components per fixel: " << cinfo.num_components << std::endl;
			std::cout << "Color space: " << cinfo.jpeg_color_space << std::endl;*/
			int picComponents = (ret->getComponents() == -1) ? cinfo.num_components : ret->getComponents();
			//std::cout << "JPG-Components: Pic: " << picComponents << " old: " << (ret->getComponents()) << " File: " << cinfo.num_components << std::endl;
			//picComponents = 4;

			// Start decompression jpeg here
			jpeg_start_decompress(&cinfo);
			ret->init(cinfo.image_width, cinfo.image_height, picComponents);
			uint8* pixels = ret->getPixels();
			//std::cout << "output width and height: " << cinfo.output_width <<" pixels and " << cinfo.output_height <<" pixels." << std::endl;
			/* now actually read the jpeg into the raw buffer */
			row_pointer[0] = new unsigned char[cinfo.output_width*cinfo.num_components];
			/* read one scan line at a time */
			/* Again you need to invert the lines unfortunately*/
			while (cinfo.output_scanline < cinfo.output_height) {
				jpeg_read_scanlines(&cinfo, row_pointer, 1);
				//Current pixel
				size_t location = (cinfo.output_height - cinfo.output_scanline) * cinfo.output_width * picComponents;
				if (picComponents == cinfo.num_components) {
					memcpy(pixels + location, row_pointer[0], cinfo.output_width*cinfo.num_components);
				} else {
					int r, g, b, a, l;
					for (unsigned int xPic = 0, xFile = 0; xPic < cinfo.output_width*picComponents; xPic += picComponents, xFile += cinfo.num_components) {
						switch (cinfo.num_components) {
							case 3:
								r = row_pointer[0][xFile];
								g = row_pointer[0][xFile + 1];
								b = row_pointer[0][xFile + 2];
								l = (r + g + b + 2) / 3;
								a = 255;
								break;
							case 4:
								r = row_pointer[0][xFile];
								g = row_pointer[0][xFile + 1];
								b = row_pointer[0][xFile + 2];
								l = (r + g + b + 2) / 3;
								a = row_pointer[0][xFile + 3];
								break;
							default:
								// Possible Error
							case 1:
								r = g = b = l = row_pointer[0][xFile];
								a = 255;
								break;
						}
						switch (picComponents) {
							case 1:
								pixels[location + xPic] = l;
								break;
							case 4:
								pixels[location + xPic + 3] = a; //Next case
							case 3:
								pixels[location + xPic] = r;
								pixels[location + xPic + 1] = g;
								pixels[location + xPic + 2] = b;
								break;
							default:
								//just so at least something works
								for (int i = 0; i < picComponents; ++i) {
									pixels[location + xPic + i] = l;
								}
								break;
								// Possible Error
						}
					}
				}
			}
			/*for(int i = 0; i < cinfo.image_width*cinfo.image_height*picComponents; ++i) {
				if (i%39 == 0) std::cout << std::endl;
				int first = pixels[i]/16;
				if (first < 10)
					std:: cout << first;
				else
					std::cout << (char)('A'+(first-10));
				first = pixels[i]%16;
				if (first < 10)
					std:: cout << first;
				else
					std::cout << (char)('A'+(first-10));
				std::cout << " ";
			}*/
			/* wrap up decompression, destroy objects, free pointers and close open files */
			jpeg_finish_decompress(&cinfo);
			jpeg_destroy_decompress(&cinfo);
			delete[] row_pointer[0];

			delete[] buffer;

			return ret;
		}

	}
} //end namespace