/*
 * This file is a part of EpnTAPClient.
 * This program aims to provide EPN-TAP support for software clients, like CASSIS spectrum analyzer.
 * See draft specifications: https://voparis-confluence.obspm.fr/pages/viewpage.action?pageId=559861
 * Copyright (C) 2016 Institut de Recherche en Astrophysique et Planétologie.
 *
 * This program is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or (at your option) any later
 * version. This program is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU General Public License for more details. You should have received a copy of
 * the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 */

package eu.omp.irap.vespa.votable.votabledata;

import java.nio.BufferUnderflowException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.StringJoiner;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.xml.bind.DatatypeConverter;

import eu.omp.irap.vespa.epntapclient.votable.model.DataType;
import eu.omp.irap.vespa.epntapclient.votable.model.Field;
import eu.omp.irap.vespa.epntapclient.votable.model.Stream;
import eu.omp.irap.vespa.votable.votable.VOTableException.CantParseVOTableException;

/**
 * @author N. Jourdane
 */
public final class BinaryStreamParser implements DataParser {

	/** The logger for the class BinaryStreamParser. */
	private static final Logger LOGGER = Logger.getLogger(BinaryStreamParser.class.getName());

	/** The XML nodes of VOTable document, containing the column names. */
	private List<Field> fieldsNodes;

	/** The byte array stored in the VOTable Table stream (if any). */
	private int rowSize;

	/** The stream to parse, containing data (column rows) stored in the VOTable. */
	private ByteBuffer stream;


	/**
	 * Constructor of BinaryStreamParser.
	 *
	 * @param voStream The stream to parse, containing data (column rows) stored in the VOTable.
	 * @param fieldsNodes the field XML nodes in VOTable document, containing the column names.
	 * @see <a href="http://www.ivoa.net/documents/REC/VOTable/VOTable-20040811.html#ToC35">The
	 *      Binary serialization in the VOTable REC.</a>
	 */
	public BinaryStreamParser(Stream voStream, List<Field> fieldsNodes) {
		this.fieldsNodes = fieldsNodes;
		String strStream = voStream.getValue().replaceAll("(\\r|\\n)", "");
		stream = ByteBuffer.wrap(DatatypeConverter.parseBase64Binary(strStream));
	}

	/**
	 * Get the size of data block according to its type.
	 *
	 * @param dataType The type of the data block, as described in the VOTable REC. See
	 *            http://www.ivoa.net/documents/REC/VOTable/VOTable-20040811.html#ToC11
	 * @return The size of the block, in bytes.
	 */
	private static int getBlockSize(DataType dataType) {
		int blockSize;
		switch (dataType) {
		case BOOLEAN:
		case UNSIGNED_BYTE:
		case CHAR:
			blockSize = 1;
			break;
		case SHORT:
		case UNICODE_CHAR:
			blockSize = 2;
			break;
		case INT:
		case FLOAT:
			blockSize = 4;
			break;
		case LONG:
		case DOUBLE:
		case FLOAT_COMPLEX:
			blockSize = 8;
			break;
		case DOUBLE_COMPLEX:
			blockSize = 16;
			break;
		default:
			blockSize = 0;
			break;
		}
		return blockSize;
	}

	@Override
	public List<Object[]> parse() throws CantParseVOTableException {
		List<Object[]> data = new ArrayList<>();
		int nbColumns = fieldsNodes.size();
		BinaryStreamParser.LOGGER
				.info("Parsing data (" + nbColumns + " columns) in BINARY stream...");
		Object[] row = new Object[nbColumns];

		int nValue = 0;
		while (stream.hasRemaining()) {
			int colId = nValue % nbColumns;
			Field column = fieldsNodes.get(colId);

			rowSize = getRowSize(column, stream);

			// May be useful: if arraySize == 0, continue

			if (colId == 0) {
				row = new Object[nbColumns];
			}

			row[colId] = processDataBlock(column.getDatatype(), rowSize, stream);

			if (colId == nbColumns - 1) {
				data.add(row);
			}
			nValue++;
		}
		return data;
	}

	/**
	 * @param column The XML node of the VOTable data, containing informations about the column,
	 *            like the data primitive type.
	 * @param byteBuffer The stream.
	 * @return The size of the row, in bytes.
	 * @throws BufferUnderflowException Can not get the array size because there is no bytes to read
	 *             in the stream.
	 */
	private static int getRowSize(Field column, ByteBuffer byteBuffer) {
		DataType dataType = column.getDatatype();
		int blockSize = getBlockSize(dataType);
		int arraySize;
		if (column.getArraysize() == null) {
			arraySize = blockSize;
		} else if ("*".equals(column.getArraysize())) {
			try {
				arraySize = byteBuffer.getInt() * blockSize;
			} catch (BufferUnderflowException e) {
				LOGGER.log(Level.SEVERE, "No space left on stream, can not get array size", e);
				throw new BufferUnderflowException();
			}
		} else {
			arraySize = Integer.parseInt(column.getArraysize()) * blockSize;
		}
		return arraySize;
	}

	/**
	 * @param dataType The type of the data block.
	 * @return An object representing the data. It can be any of the primitive type defined in the
	 *         VOtableREC. See http://www.ivoa.net/documents/REC/VOTable/VOTable-20040811.html#ToC11
	 */
	private static Object processDataBlock(DataType dataType, int rowSize, ByteBuffer stream) {
		Object dataBlock;
		int blockSize = getBlockSize(dataType);
		int nbElement = blockSize == 0 ? 0 : rowSize / blockSize;
		if (nbElement == 0) {
			return "";
		}
		if (dataType.equals(DataType.BOOLEAN)) {
			dataBlock = processBoolean(nbElement, stream);
		} else if (dataType.equals(DataType.UNSIGNED_BYTE)) {
			dataBlock = processUnsignedByte(nbElement, stream);
		} else if (dataType.equals(DataType.SHORT)) {
			dataBlock = processShort(nbElement, stream);
		} else if (dataType.equals(DataType.INT)) {
			dataBlock = processInt(nbElement, stream);
		} else if (dataType.equals(DataType.LONG)) {
			dataBlock = processLong(nbElement, stream);
		} else if (dataType.equals(DataType.CHAR)) {
			dataBlock = processChar(nbElement, stream);
		} else if (dataType.equals(DataType.UNICODE_CHAR)) {
			dataBlock = processUnicodeChar(nbElement, stream);
		} else if (dataType.equals(DataType.FLOAT)) {
			dataBlock = processFloat(nbElement, stream);
		} else if (dataType.equals(DataType.DOUBLE)) {
			dataBlock = processDouble(nbElement, stream);
		} else if (dataType.equals(DataType.FLOAT_COMPLEX)) {
			dataBlock = processFloatComplex(nbElement, stream);
		} else if (dataType.equals(DataType.DOUBLE_COMPLEX)) {
			dataBlock = processDoubleComplex(nbElement, stream);
		} else {
			BinaryStreamParser.LOGGER.warning("Data type " + dataType + " is not supported.");
			dataBlock = null;
		}
		return dataBlock;
	}

	/**
	 * Process a double complex data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processDoubleComplex(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.getDouble()));
				sj.add(String.valueOf(byteBuffer.getDouble()));
			}
			dataBlock = sj.toString();
		} else {
			StringJoiner sj = new StringJoiner(" ", "", "");
			sj.add(String.valueOf(byteBuffer.getDouble()));
			sj.add(String.valueOf(byteBuffer.getDouble()));
			dataBlock = sj.toString();
		}
		return dataBlock;
	}

	/**
	 * Process a float complex data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processFloatComplex(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.getFloat()));
				sj.add(String.valueOf(byteBuffer.getFloat()));
			}
			dataBlock = sj.toString();
		} else {
			StringJoiner sj = new StringJoiner(" ", "", "");
			sj.add(String.valueOf(byteBuffer.getFloat()));
			sj.add(String.valueOf(byteBuffer.getFloat()));
			dataBlock = sj.toString();
		}
		return dataBlock;
	}

	/**
	 * Process a double data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processDouble(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.getDouble()));
			}
			dataBlock = sj.toString();
		} else {
			dataBlock = byteBuffer.getDouble();
		}
		return dataBlock;
	}

	/**
	 * Process a float data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processFloat(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.getFloat()));
			}
			dataBlock = sj.toString();
		} else {
			dataBlock = byteBuffer.getFloat();
		}
		return dataBlock;
	}

	/**
	 * Process a unicode char data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processUnicodeChar(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		String value = new String();
		for (int i = 0; i < nbElement * 2; i += 2) {
			value += byteBuffer.getChar();
		}
		dataBlock = value.trim();
		return dataBlock;
	}

	/**
	 * Process a char data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processChar(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		String value = new String();
		for (int i = 0; i < nbElement && byteBuffer.position() < byteBuffer.limit(); i++) {
			value += (char) byteBuffer.get();
		}
		dataBlock = value.trim();
		return dataBlock;
	}

	/**
	 * Process a long data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processLong(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.getLong()));
			}
			dataBlock = sj.toString();
		} else {
			dataBlock = byteBuffer.getLong();
		}
		return dataBlock;
	}

	/**
	 * Process a int data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processInt(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.getInt()));
			}
			dataBlock = sj.toString();
		} else {
			dataBlock = byteBuffer.getInt();
		}
		return dataBlock;
	}

	/**
	 * Process a short data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processShort(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.getShort()));
			}
			dataBlock = sj.toString();
		} else {
			dataBlock = byteBuffer.getShort();
		}
		return dataBlock;
	}

	/**
	 * Process a unsigned byte data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processUnsignedByte(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(byteBuffer.get()));
			}
			dataBlock = sj.toString();
		} else {
			dataBlock = byteBuffer.get();
		}
		return dataBlock;
	}

	/**
	 * Process a boolean data type and return the result.
	 *
	 * @param nbElement The number of element inside the byte buffer.
	 * @param byteBuffer The Byte Buffer used.
	 * @return The processed data.
	 */
	private static Object processBoolean(int nbElement, ByteBuffer byteBuffer) {
		Object dataBlock;
		if (nbElement != 1) {
			StringJoiner sj = new StringJoiner(" ", "", "");
			for (int i = 0; i < nbElement; i++) {
				sj.add(String.valueOf(new Boolean(byteBuffer.getInt() == 0 ? false : true)));
			}
			dataBlock = sj.toString();
		} else {
			dataBlock = new Boolean(byteBuffer.getInt() == 0 ? false : true);
		}
		return dataBlock;
	}

	/**
	 * Decode then return the value of a TD element base64 encoded.
	 *
	 * @param content The content.
	 * @param field The field.
	 * @return The decoded value.
	 */
	public static Object readTdValue(String content, Field field) {
		String strStream = content.replaceAll("(\\r|\\n)", "");
		ByteBuffer stream = ByteBuffer.wrap(
				DatatypeConverter.parseBase64Binary(strStream));
		int rowSize = getRowSize(field, stream);
		return processDataBlock(field.getDatatype(), rowSize, stream);
	}

}