/*
    * Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org> 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.internal.storage.file;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.text.MessageFormat;
  import java.util.Arrays;
  import java.util.Iterator;
  import java.util.NoSuchElementException;
  import java.util.Set;
  
  import org.eclipse.jgit.errors.MissingObjectException;
  import org.eclipse.jgit.internal.JGitText;
  import org.eclipse.jgit.lib.AbbreviatedObjectId;
  import org.eclipse.jgit.lib.AnyObjectId;
  import org.eclipse.jgit.lib.Constants;
  import org.eclipse.jgit.lib.ObjectId;
  import org.eclipse.jgit.util.IO;
  import org.eclipse.jgit.util.NB;
  
  /** Support for the pack index v2 format. */
  class PackIndexV2 extends PackIndex {
  	private static final long IS_O64 = 1L << 31;
  
  	private static final int FANOUT = 256;
  
  	private static final int[] NO_INTS = {};
  
  	private static final byte[] NO_BYTES = {};
  
  	private long objectCnt;
  
  	private final long[] fanoutTable;
  
  	/** 256 arrays of contiguous object names. */
  	int[][] names;
  
  	/** 256 arrays of the 32 bit offset data, matching {@link #names}. */
  	byte[][] offset32;
  
  	/** 256 arrays of the CRC-32 of objects, matching {@link #names}. */
  	private byte[][] crc32;
  
  	/** 64 bit offset table. */
  	byte[] offset64;
  
  	PackIndexV2(final InputStream fd) throws IOException {
  		final byte[] fanoutRaw = new byte[4 * FANOUT];
  		IO.readFully(fd, fanoutRaw, 0, fanoutRaw.length);
  		fanoutTable = new long[FANOUT];
  		for (int k = 0; k < FANOUT; k++)
  			fanoutTable[k] = NB.decodeUInt32(fanoutRaw, k * 4);
  		objectCnt = fanoutTable[FANOUT - 1];
  
  		names = new int[FANOUT][];
  		offset32 = new byte[FANOUT][];
  		crc32 = new byte[FANOUT][];
  
  		// Object name table. The size we can permit per fan-out bucket
  		// is limited to Java's 2 GB per byte array limitation. That is
  		// no more than 107,374,182 objects per fan-out.
  		//
  		for (int k = 0; k < FANOUT; k++) {
  			final long bucketCnt;
  			if (k == 0)
  				bucketCnt = fanoutTable[k];
  			else
  				bucketCnt = fanoutTable[k] - fanoutTable[k - 1];
  
  			if (bucketCnt == 0) {
  				names[k] = NO_INTS;
  				offset32[k] = NO_BYTES;
  				crc32[k] = NO_BYTES;
  				continue;
  			} else if (bucketCnt < 0)
  				throw new IOException(MessageFormat.format(
  						JGitText.get().indexFileCorruptedNegativeBucketCount,
  						Long.valueOf(bucketCnt)));
  
  			final long nameLen = bucketCnt * Constants.OBJECT_ID_LENGTH;
  			if (nameLen > Integer.MAX_VALUE - 8) // see http://stackoverflow.com/a/8381338
  				throw new IOException(JGitText.get().indexFileIsTooLargeForJgit);
  
  			final int intNameLen = (int) nameLen;
  			final byte[] raw = new byte[intNameLen];
  			final int[] bin = new int[intNameLen >>> 2];
  			IO.readFully(fd, raw, 0, raw.length);
  			for (int i = 0; i < bin.length; i++)
  				bin[i] = NB.decodeInt32(raw, i << 2);
  
 			names[k] = bin;
 			offset32[k] = new byte[(int) (bucketCnt * 4)];
 			crc32[k] = new byte[(int) (bucketCnt * 4)];
 		}
 
 		// CRC32 table.
 		for (int k = 0; k < FANOUT; k++)
 			IO.readFully(fd, crc32[k], 0, crc32[k].length);
 
 		// 32 bit offset table. Any entries with the most significant bit
 		// set require a 64 bit offset entry in another table.
 		//
 		int o64cnt = 0;
 		for (int k = 0; k < FANOUT; k++) {
 			final byte[] ofs = offset32[k];
 			IO.readFully(fd, ofs, 0, ofs.length);
 			for (int p = 0; p < ofs.length; p += 4)
 				if (ofs[p] < 0)
 					o64cnt++;
 		}
 
 		// 64 bit offset table. Most objects should not require an entry.
 		//
 		if (o64cnt > 0) {
 			offset64 = new byte[o64cnt * 8];
 			IO.readFully(fd, offset64, 0, offset64.length);
 		} else {
 			offset64 = NO_BYTES;
 		}
 
 		packChecksum = new byte[20];
 		IO.readFully(fd, packChecksum, 0, packChecksum.length);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public long getObjectCount() {
 		return objectCnt;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public long getOffset64Count() {
 		return offset64.length / 8;
 	}
 
 	private int findLevelOne(long nthPosition) {
 		int levelOne = Arrays.binarySearch(fanoutTable, nthPosition + 1);
 		if (levelOne >= 0) {
 			// If we hit the bucket exactly the item is in the bucket, or
 			// any bucket before it which has the same object count.
 			//
 			long base = fanoutTable[levelOne];
 			while (levelOne > 0 && base == fanoutTable[levelOne - 1])
 				levelOne--;
 		} else {
 			// The item is in the bucket we would insert it into.
 			//
 			levelOne = -(levelOne + 1);
 		}
 		return levelOne;
 	}
 
 	private int getLevelTwo(long nthPosition, int levelOne) {
 		final long base = levelOne > 0 ? fanoutTable[levelOne - 1] : 0;
 		return (int) (nthPosition - base);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public ObjectId getObjectId(long nthPosition) {
 		final int levelOne = findLevelOne(nthPosition);
 		final int p = getLevelTwo(nthPosition, levelOne);
 		final int p4 = p << 2;
 		return ObjectId.fromRaw(names[levelOne], p4 + p); // p * 5
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public long getOffset(long nthPosition) {
 		final int levelOne = findLevelOne(nthPosition);
 		final int levelTwo = getLevelTwo(nthPosition, levelOne);
 		return getOffset(levelOne, levelTwo);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public long findOffset(AnyObjectId objId) {
 		final int levelOne = objId.getFirstByte();
 		final int levelTwo = binarySearchLevelTwo(objId, levelOne);
 		if (levelTwo == -1)
 			return -1;
 		return getOffset(levelOne, levelTwo);
 	}
 
 	private long getOffset(int levelOne, int levelTwo) {
 		final long p = NB.decodeUInt32(offset32[levelOne], levelTwo << 2);
 		if ((p & IS_O64) != 0)
 			return NB.decodeUInt64(offset64, (8 * (int) (p & ~IS_O64)));
 		return p;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public long findCRC32(AnyObjectId objId) throws MissingObjectException {
 		final int levelOne = objId.getFirstByte();
 		final int levelTwo = binarySearchLevelTwo(objId, levelOne);
 		if (levelTwo == -1)
 			throw new MissingObjectException(objId.copy(), "unknown"); //$NON-NLS-1$
 		return NB.decodeUInt32(crc32[levelOne], levelTwo << 2);
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public boolean hasCRC32Support() {
 		return true;
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public Iterator<MutableEntry> iterator() {
 		return new EntriesIteratorV2();
 	}
 
 	/** {@inheritDoc} */
 	@Override
 	public void resolve(Set<ObjectId> matches, AbbreviatedObjectId id,
 			int matchLimit) throws IOException {
 		int[] data = names[id.getFirstByte()];
 		int max = offset32[id.getFirstByte()].length >>> 2;
 		int high = max;
 		if (high == 0)
 			return;
 		int low = 0;
 		do {
 			int p = (low + high) >>> 1;
 			final int cmp = id.prefixCompare(data, idOffset(p));
 			if (cmp < 0)
 				high = p;
 			else if (cmp == 0) {
 				// We may have landed in the middle of the matches.  Move
 				// backwards to the start of matches, then walk forwards.
 				//
 				while (0 < p && id.prefixCompare(data, idOffset(p - 1)) == 0)
 					p--;
 				for (; p < max && id.prefixCompare(data, idOffset(p)) == 0; p++) {
 					matches.add(ObjectId.fromRaw(data, idOffset(p)));
 					if (matches.size() > matchLimit)
 						break;
 				}
 				return;
 			} else
 				low = p + 1;
 		} while (low < high);
 	}
 
 	private static int idOffset(int p) {
 		return (p << 2) + p; // p * 5
 	}
 
 	private int binarySearchLevelTwo(AnyObjectId objId, int levelOne) {
 		final int[] data = names[levelOne];
 		int high = offset32[levelOne].length >>> 2;
 		if (high == 0)
 			return -1;
 		int low = 0;
 		do {
 			final int mid = (low + high) >>> 1;
 			final int mid4 = mid << 2;
 			final int cmp;
 
 			cmp = objId.compareTo(data, mid4 + mid); // mid * 5
 			if (cmp < 0)
 				high = mid;
 			else if (cmp == 0) {
 				return mid;
 			} else
 				low = mid + 1;
 		} while (low < high);
 		return -1;
 	}
 
 	private class EntriesIteratorV2 extends EntriesIterator {
 		int levelOne;
 
 		int levelTwo;
 
 		@Override
 		protected MutableEntry initEntry() {
 			return new MutableEntry() {
 				@Override
 				protected void ensureId() {
 					idBuffer.fromRaw(names[levelOne], levelTwo
 							- Constants.OBJECT_ID_LENGTH / 4);
 				}
 			};
 		}
 
 		@Override
 		public MutableEntry next() {
 			for (; levelOne < names.length; levelOne++) {
 				if (levelTwo < names[levelOne].length) {
 					int idx = levelTwo / (Constants.OBJECT_ID_LENGTH / 4) * 4;
 					long offset = NB.decodeUInt32(offset32[levelOne], idx);
 					if ((offset & IS_O64) != 0) {
 						idx = (8 * (int) (offset & ~IS_O64));
 						offset = NB.decodeUInt64(offset64, idx);
 					}
 					entry.offset = offset;
 
 					levelTwo += Constants.OBJECT_ID_LENGTH / 4;
 					returnedNumber++;
 					return entry;
 				}
 				levelTwo = 0;
 			}
 			throw new NoSuchElementException();
 		}
 	}
 
 }