package org.hannes.archive;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.ByteBuffer;

public class Archive {

	/**
	 * The file buffer
	 */
	private final ByteBuffer buffer;

	/**
	 * The file stuff
	 */
	private File[] files;

	/**
	 * Indicates the individual files are compressed
	 */
	private final boolean compressed;

	public Archive(ByteBuffer buffer, File[] files, boolean compressed) {
		this.buffer = buffer;
		this.files = files;
		this.compressed = compressed;
	}

	/**
	 * Creates an archive from a given bufferarray stuff thingy
	 *
	 * @param data
	 * @return
	 * @throws IOException
	 */
	public static Archive create(byte[] data) throws IOException {
		return create(ByteBuffer.wrap(data));
	}

	/**
	 * Creates an archive from a given buffer
	 *
	 * @param buffer
	 * @return
	 * @throws IOException
	 */
	public static Archive create(ByteBuffer buffer) throws IOException {
		int size_decompressed = Utils.get24BitInt(buffer);
		int size_compressed = Utils.get24BitInt(buffer);

		if (size_compressed != size_decompressed) {
			byte[] data = new byte[size_compressed];
			buffer.get(data);
			buffer = ByteBuffer.wrap(Utils.decompress(data));
		}

		int size = buffer.getShort() & 0xFFFF;
		int offset = buffer.position() + size * 10;

		File[] files = new File[size];
		for (int i = 0; i < size; i++) {
			int identifier = buffer.getInt();
			int sizeDecompressed = Utils.get24BitInt(buffer);
			int sizeCompressed = Utils.get24BitInt(buffer);
			files[i] = new File(identifier, sizeDecompressed, sizeCompressed, offset);
			offset += sizeCompressed;
		}
		return new Archive(buffer, files, size_compressed != size_decompressed);
	}

	public void write() {
		ByteBuffer header = ByteBuffer.allocate(files.length * 10);
		for (int i = 0; i < files.length; i++) {
			buffer.putInt(files[i].identifier);
			Utils.put24BitInt(files[i].sizeDecompressed, header);
			Utils.put24BitInt(files[i].sizeCompressed, header);
		}

	}

	public void remove() {

	}

	public ByteBuffer getFile(int identifier) throws IOException {
		for (File file : files) {
			if (file.identifier == identifier) {
				byte[] array = new byte[file.sizeCompressed];
				buffer.position(file.offset);
				buffer.get(array, 0, file.sizeCompressed);
				System.out.println(file.sizeCompressed + "," + file.sizeDecompressed);
				if (compressed) {
					return ByteBuffer.wrap(Utils.decompress(array));
				} else {
					return ByteBuffer.wrap(array);
				}
			}
		}
		throw new FileNotFoundException("identifier (" + identifier + ") not found");
	}

	public int[] getIdentifiers() {
		int[] identifiers = new int[files.length];
		for (int i = 0; i < files.length; i++) {
			identifiers[i] = files[i].identifier;
		}
		return identifiers;
	}

	@Override
	public String toString() {
		StringBuilder builder = new StringBuilder("archive with ");
		builder.append(files.length).append(" files; buffer capacity: ").append(buffer.capacity());
		builder.append("; compressed = ").append(compressed);
		return builder.toString();
	}

	private static class File {

		/**
		 * The identifier of the file (filename)
		 */
		private final int identifier;

		/**
		 * The size when decompressed
		 */
		@SuppressWarnings("unused")
		private final int sizeDecompressed;

		/**
		 * The size of the file when it is compressed
		 */
		private final int sizeCompressed;

		/**
		 * The offset of the file in the archive
		 */
		private final int offset;

		public File(int identifier, int sizeDecompressed, int sizeCompressed, int offset) {
			this.identifier = identifier;
			this.sizeDecompressed = sizeDecompressed;
			this.sizeCompressed = sizeCompressed;
			this.offset = offset;
		}

	}

}