/*
 * Copyright (C) 2015, Matthias Sohn <matthias.sohn@sap.com> and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package org.eclipse.jgit.lfs.lib;

import java.text.MessageFormat;

import org.eclipse.jgit.lfs.errors.InvalidLongObjectIdException;
import org.eclipse.jgit.lfs.internal.LfsText;
import org.eclipse.jgit.util.NB;
import org.eclipse.jgit.util.RawParseUtils;

/**
 * A mutable SHA-256 abstraction.
 *
 * Ported to SHA-256 from {@link org.eclipse.jgit.lib.MutableObjectId}
 *
 * @since 4.3
 */
public class MutableLongObjectId extends AnyLongObjectId {
	/**
	 * Empty constructor. Initialize object with default (zeros) value.
	 */
	public MutableLongObjectId() {
		super();
	}

	/**
	 * Copying constructor.
	 *
	 * @param src
	 *            original entry, to copy id from
	 */
	MutableLongObjectId(MutableLongObjectId src) {
		fromObjectId(src);
	}

	/**
	 * Set any byte in the id.
	 *
	 * @param index
	 *            index of the byte to set in the raw form of the ObjectId. Must
	 *            be in range [0,
	 *            {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH}).
	 * @param value
	 *            the value of the specified byte at {@code index}. Values are
	 *            unsigned and thus are in the range [0,255] rather than the
	 *            signed byte range of [-128, 127].
	 * @throws java.lang.ArrayIndexOutOfBoundsException
	 *             {@code index} is less than 0, equal to
	 *             {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH},
	 *             or greater than
	 *             {@link org.eclipse.jgit.lfs.lib.Constants#LONG_OBJECT_ID_LENGTH}.
	 */
	public void setByte(int index, int value) {
		switch (index >> 3) {
		case 0:
			w1 = set(w1, index & 7, value);
			break;
		case 1:
			w2 = set(w2, index & 7, value);
			break;
		case 2:
			w3 = set(w3, index & 7, value);
			break;
		case 3:
			w4 = set(w4, index & 7, value);
			break;
		default:
			throw new ArrayIndexOutOfBoundsException(index);
		}
	}

	private static long set(long w, int index, long value) {
		value &= 0xff;

		switch (index) {
		case 0:
			return (w & 0x00ffffffffffffffL) | (value << 56);
		case 1:
			return (w & 0xff00ffffffffffffL) | (value << 48);
		case 2:
			return (w & 0xffff00ffffffffffL) | (value << 40);
		case 3:
			return (w & 0xffffff00ffffffffL) | (value << 32);
		case 4:
			return (w & 0xffffffff00ffffffL) | (value << 24);
		case 5:
			return (w & 0xffffffffff00ffffL) | (value << 16);
		case 6:
			return (w & 0xffffffffffff00ffL) | (value << 8);
		case 7:
			return (w & 0xffffffffffffff00L) | value;
		default:
			throw new ArrayIndexOutOfBoundsException();
		}
	}

	/**
	 * Make this id match
	 * {@link org.eclipse.jgit.lfs.lib.LongObjectId#zeroId()}.
	 */
	public void clear() {
		w1 = 0;
		w2 = 0;
		w3 = 0;
		w4 = 0;
	}

	/**
	 * Copy a LongObjectId into this mutable buffer.
	 *
	 * @param src
	 *            the source id to copy from.
	 */
	public void fromObjectId(AnyLongObjectId src) {
		this.w1 = src.w1;
		this.w2 = src.w2;
		this.w3 = src.w3;
		this.w4 = src.w4;
	}

	/**
	 * Convert a LongObjectId from raw binary representation.
	 *
	 * @param bs
	 *            the raw byte buffer to read from. At least 32 bytes must be
	 *            available within this byte array.
	 */
	public void fromRaw(byte[] bs) {
		fromRaw(bs, 0);
	}

	/**
	 * Convert a LongObjectId from raw binary representation.
	 *
	 * @param bs
	 *            the raw byte buffer to read from. At least 32 bytes after p
	 *            must be available within this byte array.
	 * @param p
	 *            position to read the first byte of data from.
	 */
	public void fromRaw(byte[] bs, int p) {
		w1 = NB.decodeInt64(bs, p);
		w2 = NB.decodeInt64(bs, p + 8);
		w3 = NB.decodeInt64(bs, p + 16);
		w4 = NB.decodeInt64(bs, p + 24);
	}

	/**
	 * Convert a LongObjectId from binary representation expressed in integers.
	 *
	 * @param longs
	 *            the raw long buffer to read from. At least 4 longs must be
	 *            available within this longs array.
	 */
	public void fromRaw(long[] longs) {
		fromRaw(longs, 0);
	}

	/**
	 * Convert a LongObjectId from binary representation expressed in longs.
	 *
	 * @param longs
	 *            the raw int buffer to read from. At least 4 longs after p must
	 *            be available within this longs array.
	 * @param p
	 *            position to read the first integer of data from.
	 */
	public void fromRaw(long[] longs, int p) {
		w1 = longs[p];
		w2 = longs[p + 1];
		w3 = longs[p + 2];
		w4 = longs[p + 3];
	}

	/**
	 * Convert a LongObjectId from hex characters (US-ASCII).
	 *
	 * @param buf
	 *            the US-ASCII buffer to read from. At least 32 bytes after
	 *            offset must be available within this byte array.
	 * @param offset
	 *            position to read the first character from.
	 */
	public void fromString(byte[] buf, int offset) {
		fromHexString(buf, offset);
	}

	/**
	 * Convert a LongObjectId from hex characters.
	 *
	 * @param str
	 *            the string to read from. Must be 64 characters long.
	 */
	public void fromString(String str) {
		if (str.length() != Constants.LONG_OBJECT_ID_STRING_LENGTH)
			throw new IllegalArgumentException(
					MessageFormat.format(LfsText.get().invalidLongId, str));
		fromHexString(org.eclipse.jgit.lib.Constants.encodeASCII(str), 0);
	}

	private void fromHexString(byte[] bs, int p) {
		try {
			w1 = RawParseUtils.parseHexInt64(bs, p);
			w2 = RawParseUtils.parseHexInt64(bs, p + 16);
			w3 = RawParseUtils.parseHexInt64(bs, p + 32);
			w4 = RawParseUtils.parseHexInt64(bs, p + 48);
		} catch (ArrayIndexOutOfBoundsException e) {
			InvalidLongObjectIdException e1 = new InvalidLongObjectIdException(
					bs, p, Constants.LONG_OBJECT_ID_STRING_LENGTH);
			e1.initCause(e);
			throw e1;
		}
	}

	@Override
	public LongObjectId toObjectId() {
		return new LongObjectId(this);
	}
}