/**
 * @author Nikos M. / https://github.com/foo123/
 */

// https://github.com/mrdoob/three.js/issues/5552
// http://en.wikipedia.org/wiki/RGBE_image_format

THREE.HDRLoader = THREE.RGBELoader = function ( manager ) {

	this.manager = ( manager !== undefined ) ? manager : THREE.DefaultLoadingManager;

};

// extend THREE.BinaryTextureLoader
THREE.RGBELoader.prototype = Object.create( THREE.BinaryTextureLoader.prototype );

// adapted from http://www.graphics.cornell.edu/~bjw/rgbe.html
THREE.RGBELoader.prototype._parser = function( buffer ) {

	var
		/* return codes for rgbe routines */
		RGBE_RETURN_SUCCESS =  0,
		RGBE_RETURN_FAILURE = -1,

		/* default error routine.  change this to change error handling */
		rgbe_read_error     = 1,
		rgbe_write_error    = 2,
		rgbe_format_error   = 3,
		rgbe_memory_error   = 4,
		rgbe_error = function(rgbe_error_code, msg) {
			switch (rgbe_error_code) {
				case rgbe_read_error: console.error("THREE.RGBELoader Read Error: " + (msg||''));
				break;
				case rgbe_write_error: console.error("THREE.RGBELoader Write Error: " + (msg||''));
				break;
				case rgbe_format_error:  console.error("THREE.RGBELoader Bad File Format: " + (msg||''));
				break;
				default:
				case rgbe_memory_error:  console.error("THREE.RGBELoader: Error: " + (msg||''));
			}
			return RGBE_RETURN_FAILURE;
		},

		/* offsets to red, green, and blue components in a data (float) pixel */
		RGBE_DATA_RED      = 0,
		RGBE_DATA_GREEN    = 1,
		RGBE_DATA_BLUE     = 2,

		/* number of floats per pixel, use 4 since stored in rgba image format */
		RGBE_DATA_SIZE     = 4,

		/* flags indicating which fields in an rgbe_header_info are valid */
		RGBE_VALID_PROGRAMTYPE      = 1,
		RGBE_VALID_FORMAT           = 2,
		RGBE_VALID_DIMENSIONS       = 4,

		NEWLINE = "\n",

		fgets = function( buffer, lineLimit, consume ) {
			lineLimit = !lineLimit ? 1024 : lineLimit;
			var p = buffer.pos,
				i = -1, len = 0, s = '', chunkSize = 128,
				chunk = String.fromCharCode.apply(null, new Uint16Array( buffer.subarray( p, p+chunkSize ) ) )
			;
			while ( (0 > (i=chunk.indexOf( NEWLINE ))) && (len < lineLimit) && (p < buffer.byteLength) ) {

				s += chunk; len += chunk.length;
				p += chunkSize;
				chunk += String.fromCharCode.apply(null, new Uint16Array( buffer.subarray( p, p+chunkSize ) ) );

			}

			if ( -1 < i ) {

				/*for (i=l-1; i>=0; i--) {
					byteCode = m.charCodeAt(i);
					if (byteCode > 0x7f && byteCode <= 0x7ff) byteLen++;
					else if (byteCode > 0x7ff && byteCode <= 0xffff) byteLen += 2;
					if (byteCode >= 0xDC00 && byteCode <= 0xDFFF) i--; //trail surrogate
				}*/
				if ( false !== consume ) buffer.pos += len+i+1;
				return s + chunk.slice(0, i);

			}
			return false;
		},

		/* minimal header reading.  modify if you want to parse more information */
		RGBE_ReadHeader = function( buffer ) {
			var line, match,

				// regexes to parse header info fields
				magic_token_re = /^#\?(\S+)$/,
				gamma_re = /^\s*GAMMA\s*=\s*(\d+(\.\d+)?)\s*$/,
				exposure_re = /^\s*EXPOSURE\s*=\s*(\d+(\.\d+)?)\s*$/,
				format_re = /^\s*FORMAT=(\S+)\s*$/,
				dimensions_re = /^\s*\-Y\s+(\d+)\s+\+X\s+(\d+)\s*$/,

				// RGBE format header struct
				header = {

				  valid: 0,                         /* indicate which fields are valid */

				  string: '',                       /* the actual header string */

				  comments: '',                     /* comments found in header */

				  programtype: 'RGBE',              /* listed at beginning of file to identify it
													* after "#?".  defaults to "RGBE" */

				  format: '',                       /* RGBE format, default 32-bit_rle_rgbe */

				  gamma: 1.0,                       /* image has already been gamma corrected with
													* given gamma.  defaults to 1.0 (no correction) */

				  exposure: 1.0,                    /* a value of 1.0 in an image corresponds to
													* <exposure> watts/steradian/m^2.
													* defaults to 1.0 */

				  width: 0, height: 0               /* image dimensions, width/height */

				}
			;

			if ( buffer.pos >= buffer.byteLength || !( line=fgets( buffer ) ) ) {
				return rgbe_error( rgbe_read_error, "no header found" );
			}
			/* if you want to require the magic token then uncomment the next line */
			if ( !(match=line.match(magic_token_re)) ) {
				return rgbe_error( rgbe_format_error, "bad initial token" );
			}
			header.valid |= RGBE_VALID_PROGRAMTYPE;
			header.programtype = match[1];
			header.string += line + "\n";

			while ( true ) {

				line = fgets( buffer );
				if ( false === line ) break;
				header.string += line + "\n";

				if ( '#' === line.charAt(0) ) {
					header.comments += line + "\n";
					continue; // comment line
				}

				if ( match=line.match(gamma_re) ) {
					header.gamma = parseFloat(match[1], 10);
				}
				if ( match=line.match(exposure_re) ) {
					header.exposure = parseFloat(match[1], 10);
				}
				if ( match=line.match(format_re) ) {
					header.valid |= RGBE_VALID_FORMAT;
					header.format = match[1];//'32-bit_rle_rgbe';
				}
				if ( match=line.match(dimensions_re) ) {
					header.valid |= RGBE_VALID_DIMENSIONS;
					header.height = parseInt(match[1], 10);
					header.width = parseInt(match[2], 10);
				}

				if ( (header.valid&RGBE_VALID_FORMAT) && (header.valid&RGBE_VALID_DIMENSIONS) ) break;
			}

			if ( !(header.valid&RGBE_VALID_FORMAT) ) {
				return rgbe_error( rgbe_format_error, "missing format specifier" );
			}
			if ( !(header.valid&RGBE_VALID_DIMENSIONS) ) {
				return rgbe_error( rgbe_format_error, "missing image size specifier" );
			}

			return header;
		},

		RGBE_ReadPixels_RLE = function( buffer, w, h ) {
			var data_rgba, offset, pos, count, byteValue,
				scanline_buffer, ptr, ptr_end, i, l, off, isEncodedRun,
				scanline_width = w, num_scanlines = h, rgbeStart
			;

			if (
				// run length encoding is not allowed so read flat
				((scanline_width < 8) || (scanline_width > 0x7fff)) ||
				// this file is not run length encoded
				((2 !== buffer[0]) || (2 !== buffer[1]) || (buffer[2] & 0x80))
			) {
				// return the flat buffer
				return new Uint8Array( buffer );
			}

			if ( scanline_width !== ((buffer[2]<<8) | buffer[3]) ) {
				return rgbe_error(rgbe_format_error, "wrong scanline width");
			}

			data_rgba = new Uint8Array( 4*w*h );

			if ( !data_rgba || !data_rgba.length ) {
				return rgbe_error(rgbe_memory_error, "unable to allocate buffer space");
			}

			offset = 0; pos = 0; ptr_end = 4*scanline_width;
			rgbeStart = new Uint8Array( 4 );
			scanline_buffer = new Uint8Array( ptr_end );

			// read in each successive scanline
			while( (num_scanlines > 0) && (pos < buffer.byteLength) ) {

				if ( pos+4 > buffer.byteLength ) {

					return rgbe_error( rgbe_read_error );

				}

				rgbeStart[0] = buffer[pos++];
				rgbeStart[1] = buffer[pos++];
				rgbeStart[2] = buffer[pos++];
				rgbeStart[3] = buffer[pos++];

				if ( (2 != rgbeStart[0]) || (2 != rgbeStart[1]) || (((rgbeStart[2]<<8) | rgbeStart[3]) != scanline_width) ) {

					return rgbe_error(rgbe_format_error, "bad rgbe scanline format");

				}

				// read each of the four channels for the scanline into the buffer
				// first red, then green, then blue, then exponent
				ptr = 0;
				while ( (ptr < ptr_end) && (pos < buffer.byteLength) ) {

					count = buffer[ pos++ ];
					isEncodedRun = count > 128;
					if ( isEncodedRun ) count -= 128;

					if ( (0 === count) || (ptr+count > ptr_end) ) {

						return rgbe_error(rgbe_format_error, "bad scanline data");

					}

					if ( isEncodedRun ) {
						// a (encoded) run of the same value
						byteValue = buffer[ pos++ ];
						for (i=0; i<count; i++) {
							scanline_buffer[ ptr++ ] = byteValue;
						}
						//ptr += count;

					} else {
						// a literal-run
						scanline_buffer.set( buffer.subarray(pos, pos+count), ptr );
						ptr += count; pos += count;
					}
				}


				// now convert data from buffer into rgba
				// first red, then green, then blue, then exponent (alpha)
				l = scanline_width; //scanline_buffer.byteLength;
				for (i=0; i<l; i++) {
					off = 0;
					data_rgba[offset] = scanline_buffer[i+off];
					off += scanline_width; //1;
					data_rgba[offset+1] = scanline_buffer[i+off];
					off += scanline_width; //1;
					data_rgba[offset+2] = scanline_buffer[i+off];
					off += scanline_width; //1;
					data_rgba[offset+3] = scanline_buffer[i+off];
					offset += 4;
				}

				num_scanlines--;
			}

			return data_rgba;
		}
	;

	var byteArray = new Uint8Array( buffer ),
		byteLength = byteArray.byteLength;
	byteArray.pos = 0;
	var rgbe_header_info = RGBE_ReadHeader( byteArray );

	if ( RGBE_RETURN_FAILURE !== rgbe_header_info ) {

		var w = rgbe_header_info.width,
			h = rgbe_header_info.height
			,image_rgba_data = RGBE_ReadPixels_RLE( byteArray.subarray(byteArray.pos), w, h )
		;
		if ( RGBE_RETURN_FAILURE !== image_rgba_data ) {
			return {
				width: w, height: h,
				data: image_rgba_data,
				header: rgbe_header_info.string,
				gamma: rgbe_header_info.gamma,
				exposure: rgbe_header_info.exposure,
				format: THREE.RGBEFormat, // handled as THREE.RGBAFormat in shaders
				type: THREE.UnsignedByteType
			};
		}
	}
	return null;
};