#region Copyright & License Information
/*
 * Copyright 2007-2010 The OpenRA Developers (see AUTHORS)
 * This file is part of OpenRA, which is free software. It is made 
 * available to you under the terms of the GNU General Public License
 * as published by the Free Software Foundation. For more information,
 * see LICENSE.
 */
#endregion

using System.Collections;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System;
using System.Drawing.Imaging;

namespace OpenRA.FileFormats
{
	public class VqaReader
	{
		public readonly ushort Frames;
		public readonly byte Framerate;
		public readonly ushort Width;
		public readonly ushort Height;
		
		Stream stream;
		int currentFrame;
		ushort flags;
		ushort numColors;
		ushort blockWidth;
		ushort blockHeight;
		byte cbParts;
		int2 blocks;
		UInt32[] offsets;
		int[] palette;

		// Stores a list of subpixels, referenced by the VPTZ chunk
		byte[] cbf;
		byte[] cbp;			
		int cbChunk = 0;
		int cbOffset = 0;
		
		// Top half contains block info, bottom half contains references to cbf array
		byte[] origData;
		
		// Final frame output
		int[,] frameData;
		
		public VqaReader( Stream stream )
		{
			this.stream = stream;
			BinaryReader reader = new BinaryReader( stream );
			
			// Decode FORM chunk
			if (new String(reader.ReadChars(4)) != "FORM")
				throw new InvalidDataException("Invalid vqa (invalid FORM section)");
			/*var length = */ reader.ReadUInt32();
			
			if (new String(reader.ReadChars(8)) != "WVQAVQHD")
				throw new InvalidDataException("Invalid vqa (not WVQAVQHD)");
			/* var length = */reader.ReadUInt32();
			
			/*var version = */reader.ReadUInt16();
			flags = reader.ReadUInt16();
			Frames = reader.ReadUInt16();
			Width = reader.ReadUInt16();
			Height = reader.ReadUInt16();
			
			blockWidth = reader.ReadByte();
			blockHeight = reader.ReadByte();
			Framerate = reader.ReadByte();
			cbParts = reader.ReadByte();
			blocks = new int2(Width / blockWidth, Height / blockHeight);
			
			numColors = reader.ReadUInt16();
			/*var maxBlocks = */reader.ReadUInt16();
			/*var unknown1 = */reader.ReadUInt16();
			/*var unknown2 = */reader.ReadUInt32();
			
			// Audio
			/*var freq = */reader.ReadUInt16();
			/*var channels = */reader.ReadByte();
			/*var bits = */reader.ReadByte();
			/*var unknown3 = */reader.ReadChars(14);
			
			var frameSize = NextPowerOf2(Math.Max(Width,Height));
			cbf = new byte[Width*Height];
			cbp = new byte[Width*Height];
			palette = new int[numColors];
			origData = new byte[2*blocks.X*blocks.Y];
			frameData = new int[frameSize,frameSize];
			
			// Decode FINF chunk
			if (new String(reader.ReadChars(4)) != "FINF")
				throw new InvalidDataException("Invalid vqa (invalid FINF section)");
			/*var length = */reader.ReadUInt16();
			/*var unknown4 = */reader.ReadUInt16();
			
			// Frame offsets
			offsets = new UInt32[Frames];
			for (int i = 0; i < Frames; i++)
			{
				offsets[i] = reader.ReadUInt32();
				if (offsets[i] > 0x40000000) offsets[i] -= 0x40000000;
				offsets[i] <<= 1;
			}
			
			// Load the first frame
			currentFrame = 0;
			AdvanceFrame();
		}
		
		public void AdvanceFrame()
		{			
			// Seek to the start of the frame
			stream.Seek(offsets[currentFrame], SeekOrigin.Begin);
			BinaryReader reader = new BinaryReader(stream);
			var end = (currentFrame < Frames - 1) ? offsets[currentFrame+1] : stream.Length;
	
			while(reader.BaseStream.Position < end)
			{
				var type = new String(reader.ReadChars(4));
				var length = Swap(reader.ReadUInt32());

				switch(type)
				{
					case "SND2":
						// Don't parse sound (yet); skip data
						reader.ReadBytes((int)length);
					break;
					case "VQFR":
						DecodeVQFR(reader);
					break;
					default: 
						throw new InvalidDataException("Unknown chunk {0}".F(type));
				}
				
				// Chunks are aligned on even bytes; advance by a byte if the next one is null
				if (reader.PeekChar() == 0) reader.ReadByte();
			}
			if (++currentFrame == Frames)
				currentFrame = cbOffset = cbChunk = 0;
		}
		
		// VQA Frame
		public void DecodeVQFR(BinaryReader reader)
		{			
			while(true)
			{				
				// Chunks are aligned on even bytes; may be padded with a single null
				if (reader.PeekChar() == 0) reader.ReadByte();
				var type = new String(reader.ReadChars(4));
				int subchunkLength = (int)Swap(reader.ReadUInt32());

				switch(type)
				{
					// Full frame-modifier
					case "CBFZ":
						Format80.DecodeInto( reader.ReadBytes(subchunkLength), cbf );
					break;
					case "CBF0":
						cbf = reader.ReadBytes(subchunkLength);
					break;
					
					// frame-modifier chunk
					case "CBP0":	
					case "CBPZ":
						// Partial buffer is full; dump and recreate
						if (cbChunk == cbParts)
						{
							if (type == "CBP0")
								cbf = (byte[])cbp.Clone();
							else
								Format80.DecodeInto( cbp, cbf );
							
							cbOffset = cbChunk = 0;
						}
						
						var bytes = reader.ReadBytes(subchunkLength);
						bytes.CopyTo(cbp,cbOffset);
						cbOffset += subchunkLength;
						cbChunk++;
					break;
					
					// Palette
					case "CPL0":
						for (int i = 0; i < numColors; i++)
						{
							byte r = reader.ReadByte();
							byte g = reader.ReadByte();
							byte b = reader.ReadByte();
							palette[i] = Color.FromArgb(255,ToColorByte(r),ToColorByte(g),ToColorByte(b)).ToArgb();
						}
					break;
					
					// Frame data
					case "VPTZ":
						Format80.DecodeInto( reader.ReadBytes(subchunkLength), origData );
						// This is the last subchunk
						return;
					default:
						throw new InvalidDataException("Unknown sub-chunk {0}".F(type));
				}
			}
		}
		
		public int[,] FrameData()
		{
			for (var y = 0; y < blocks.Y; y++)
				for (var x = 0; x < blocks.X; x++)
				{
					var px = origData[x + y*blocks.X];
					var mod = origData[x + (y + blocks.Y)*blocks.X];
					for (var j = 0; j < blockHeight; j++)
						for (var i = 0; i < blockWidth; i++)
						{
							var cbfi = (mod*256 + px)*8 + j*blockWidth + i;
							byte color = (mod == 0x0f) ? px : cbf[cbfi];
							frameData[y*blockHeight + j, x*blockWidth + i] = palette[color];
						}
				}
			return frameData;
		}
		
		int NextPowerOf2(int v)
		{
			--v;
			v |= v >> 1;
			v |= v >> 2;
			v |= v >> 4;
			v |= v >> 8;
			++v;
			return v;
		}
		
		public byte ToColorByte(byte b)
		{
			return (byte)((b & 63) * 255 / 63);
		}
		
		// Change endianness of a uint32
		public UInt32 Swap(UInt32 orig)
		{
			return (UInt32)((orig & 0xff000000) >> 24) | ((orig & 0x00ff0000) >> 8) | ((orig & 0x0000ff00) << 8) | ((orig & 0x000000ff) << 24);
		}		
	}
}