package ar.com.hjg.pngj;

import ar.com.hjg.pngj.chunks.ChunkRaw;

/**
 * Parses a PNG chunk, consuming bytes in one mode:
 * {@link ChunkReaderMode#BUFFER}, {@link ChunkReaderMode#PROCESS},
 * {@link ChunkReaderMode#SKIP}.
 * <p>
 * It calls {@link #chunkDone()} when done. Also calls
 * {@link #processData(byte[], int, int)} if <code>PROCESS</code>
 * mode. Apart from thas, it's totally agnostic (it doesn't know about IDAT
 * chunks, or PNG general structure)
 * <p>
 * The object wraps a ChunkRaw instance (content filled only if BUFFER mode); it
 * should be short lived (one instance
 * created for each chunk, and discarded after reading), but the wrapped
 * chunkRaw can be (usually is) long lived.
 */
public abstract class ChunkReader {

	/**
	 * see {@link ChunkReaderMode}
	 */
	public final ChunkReaderMode mode;
	private final ChunkRaw chunkRaw;

	private boolean crcCheck; // by default, this is false for SKIP, true elsewhere

	/**
	 * How many bytes have been read for this chunk, data only
	 */
	protected int read = 0;
	private int crcn = 0; // how many bytes have been read from crc

	/**
	 * Modes of ChunkReader chunk processing.
	 */
	public enum ChunkReaderMode {
		/**
		 * Stores full chunk data in buffer
		 */
		BUFFER,
		/**
		 * Does not store content, processes on the fly, calling processData()
		 * for each partial read
		 */
		PROCESS,
		/**
		 * Does not store nor process - implies crcCheck=false (by default).
		 */
		SKIP;
	}

	/**
	 * The constructor creates also a chunkRaw, preallocated if mode =
	 * ChunkReaderMode.BUFFER
	 * 
	 * @param clen
	 * @param id
	 * @param offsetInPng
	 *            Informational, is stored in chunkRaw
	 * @param mode
	 */
	public ChunkReader(int clen, String id, long offsetInPng, ChunkReaderMode mode) {
		if (mode == null || id.length() != 4 || clen < 0)
			throw new PngjExceptionInternal("Bad chunk paramenters: " + mode);
		this.mode = mode;
		chunkRaw = new ChunkRaw(clen, id, mode == ChunkReaderMode.BUFFER);
		chunkRaw.setOffset(offsetInPng);
		this.crcCheck = mode == ChunkReaderMode.SKIP ? false : true; // can be changed with setter
	}

	/**
	 * Returns raw chunk (data can be empty or not, depending on
	 * ChunkReaderMode)
	 * 
	 * @return Raw chunk - never null
	 */
	public ChunkRaw getChunkRaw() {
		return chunkRaw;
	}

	/**
	 * Consumes data for the chunk (data and CRC). This never consumes more
	 * bytes than for this chunk.
	 * 
	 * In HOT_PROCESS can call processData() (not more than once)
	 * 
	 * If this ends the chunk (included CRC) it checks CRC (if checking) and
	 * calls chunkDone()
	 * 
	 * @param buf
	 * @param off
	 * @param len
	 * @return How many bytes have been consumed
	 */
	public final int feedBytes(byte[] buf, int off, int len) {
		if (len == 0)
			return 0;
		if (len < 0)
			throw new PngjException("negative length??");
		if (read == 0 && crcn == 0 && crcCheck)
			chunkRaw.updateCrc(chunkRaw.idbytes, 0, 4); // initializes crc calculation with the Chunk ID
		int bytesForData = chunkRaw.len - read; // bytesForData : bytes to be actually read from chunk data
		if (bytesForData > len)
			bytesForData = len;
		// we want to call processData even for empty chunks (IEND:bytesForData=0) at least once
		if (bytesForData > 0 || crcn == 0) {
			// in buffer mode we compute the CRC at the end
			if (crcCheck && mode != ChunkReaderMode.BUFFER && bytesForData > 0)
				chunkRaw.updateCrc(buf, off, bytesForData);

			if (mode == ChunkReaderMode.BUFFER) {
				// just copy the contents to the internal buffer
				if (chunkRaw.data != buf && bytesForData > 0) {
					// if the buffer passed if the same as this one, we don't copy the caller should know what he's doing
					System.arraycopy(buf, off, chunkRaw.data, read, bytesForData);
				}
			} else if (mode == ChunkReaderMode.PROCESS) {
				processData(read, buf, off, bytesForData);
			} else {
				// mode == ChunkReaderMode.SKIP; nothing to do
			}
			read += bytesForData;
			off += bytesForData;
			len -= bytesForData;
		}
		int crcRead = 0;
		if (read == chunkRaw.len) { // data done - read crc?
			crcRead = 4 - crcn;
			if (crcRead > len)
				crcRead = len;
			if (crcRead > 0) {
				if (buf != chunkRaw.crcval)
					System.arraycopy(buf, off, chunkRaw.crcval, crcn, crcRead);
				crcn += crcRead;
				if (crcn == 4) {
					if (crcCheck) {
						if (mode == ChunkReaderMode.BUFFER) { // in buffer mode we compute the CRC on one single call
							chunkRaw.updateCrc(chunkRaw.data, 0, chunkRaw.len);
						}
						chunkRaw.checkCrc();
					}
					chunkDone();
				}
			}
		}
		return bytesForData + crcRead;
	}

	/**
	 * Chunks has been read
	 * 
	 * @return true if we have read all chunk, including trailing CRC
	 */
	public final boolean isDone() {
		return crcn == 4; // has read all 4 bytes from the crc
	}

	/**
	 * Determines if CRC should be checked. This should be called before
	 * starting reading.
	 * 
	 * @param crcCheck
	 */
	public void setCrcCheck(boolean crcCheck) {
		if (read != 0 && crcCheck && !this.crcCheck)
			throw new PngjException("too late!");
		this.crcCheck = crcCheck;
	}

	/**
	 * This method will only be called in PROCESS mode, probably several times,
	 * each time with a new fragment of data
	 * inside the chunk. For chunks with zero-length data, this will still be
	 * called once.
	 * 
	 * It's guaranteed that the data corresponds exclusively to this chunk data
	 * (no crc, no data from no other chunks, )
	 * 
	 * @param offsetInchunk
	 *            data bytes that had already been read/processed for this chunk
	 * @param buf
	 * @param off
	 * @param len
	 */
	protected abstract void processData(int offsetInchunk, byte[] buf, int off, int len);

	/**
	 * This method will be called (in all modes) when the full chunk -including
	 * crc- has been read
	 */
	protected abstract void chunkDone();

	public boolean isFromDeflatedSet() {
		return false;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((chunkRaw == null) ? 0 : chunkRaw.hashCode());
		return result;
	}

	/**
	 * Equality (and hash) is basically delegated to the ChunkRaw
	 */
	@Override
	public boolean equals(Object obj) { // delegates to chunkraw
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		ChunkReader other = (ChunkReader) obj;
		if (chunkRaw == null) {
			if (other.chunkRaw != null)
				return false;
		} else if (!chunkRaw.equals(other.chunkRaw))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return chunkRaw.toString();
	}

}