//@formatter:off
/*
 * Auther: tukune
 * 
 * DON'T CODE FORMAT!
 * DON'T CONVERT TAB <---> SPACE
 * DON'T STRIP TRAILING BLANKS FROM END OF LINE
 */
package jp.sf.l2j.arrayMaps;

import static jp.sf.l2j.arrayMaps.SortedArrayMap.*;

import java.util.Arrays;
import java.util.Map;
import java.util.Map.Entry;

/*
 * @auther JOJO
 */
public class SortedIntByteArrayMap
{
	private int[] _keys;
	private byte[] _values;
	public final byte NULL;
	
	public SortedIntByteArrayMap()
	{
		this(BYTE_NULL);
	}
	
	public SortedIntByteArrayMap(byte nullValue)
	{
		this(nullValue, INT_EMPTY, BYTE_EMPTY);
	}
	
	public SortedIntByteArrayMap(int[] keys, byte[] values)
	{
		this(BYTE_NULL, keys, values);
	}
	
	public SortedIntByteArrayMap(byte nullValue, int[] keys, byte[] values)
	{
		NULL = nullValue;
		_keys = keys;
		_values = values;
		sort();
	}
	
	public SortedIntByteArrayMap(Map<Integer, Byte> t)
	{
		this(BYTE_NULL, t);
	}
	
	public SortedIntByteArrayMap(byte nullValue, Map<Integer, Byte> t)
	{
		NULL = nullValue;
		int length = t.size();
		int[] _keys = new int[length];
		byte[] _values = new byte[length];
		
		Byte w;
		int index = 0;
		for (Entry<Integer, Byte> e : t.entrySet())
		{
			_keys[index] = e.getKey();
			_values[index] = (w = e.getValue()) == null ? NULL : w;
			++index;
		}
		sort();
	}
	
	public void clear()
	{
		_keys = INT_EMPTY;
		_values = BYTE_EMPTY;
	}
	
	public boolean containsKey(int key)
	{
		return Arrays.binarySearch(_keys, key) >= 0;
	}
	
	public boolean containsValue(byte value)
	{
		for (int i = 0, length = _values.length; i < length; ++i)
			if (_values[i] == value)
				return true;
		return false;
	}
	
	public byte get(int key)
	{
		return get(key, NULL);
	}
	
	public byte get(int key, byte defaultValue)
	{
		int i = Arrays.binarySearch(_keys, key);
		if (i >= 0)
			return _values[i];
		else
			return defaultValue;
	}
	
	public boolean isEmpty()
	{
		return _keys.length == 0;
	}
	
	public int[] keySet()
	{
		return _keys;
	}
	
	public int[] keys()
	{
		return _keys;
	}
	
	public byte put(int key, byte value)
	{
		int index = Arrays.binarySearch(_keys, key);
		if (index >= 0) {
			byte prev = _values[index];
			_values[index] = value;
			return prev;
		} else {
			return insertEntry(-(index + 1), key, value);
		}
	}
	
	public byte putIfAbsent(int key, byte value)
	{
		int index = Arrays.binarySearch(_keys, key);
		if (index >= 0)
			return _values[index];
		else
			return insertEntry(-(index + 1), key, value);
	}
	
	public void putAll(Map<Integer, Byte> t)
	{
		for (Entry<Integer, Byte> e : t.entrySet())
			put(e.getKey(), e.getValue());
	}
	
	public byte remove(int key)
	{
		int index = Arrays.binarySearch(_keys, key);
		if (index >= 0)
			return deleteEntry(index);
		else
			return NULL;
	}
	
	public int size()
	{
		return _keys.length;
	}
	
	public byte[] values()
	{
		return _values;
	}
	
	public SortedIntByteArrayMap append(int key, byte value)
	{
		byte prev = put(key, value);
		if (prev != NULL) throw new RuntimeException("Duplicate key:" + key + " value:" + value + " previus:" + prev);
		return this;
	}
	
	private byte deleteEntry(int index)
	{
		final int length = _keys.length - 1;
		if (length < 0)
			return NULL;
		int[] tmpKeys = new int[length];
		byte[] tmpValues = new byte[length];
		if (index > 0) {
			System.arraycopy(_keys, 0, tmpKeys, 0, index);
			System.arraycopy(_values, 0, tmpValues, 0, index);
		}
		int n;
		if ((n = length - index) > 0) {
			System.arraycopy(_keys, index + 1, tmpKeys, index, n);
			System.arraycopy(_values, index + 1, tmpValues, index, n);
		}
		byte prev = _values[index];
		_keys = tmpKeys;
		_values = tmpValues;
		return prev;
	}
	
	public int indexOf(int key)
	{
		return Arrays.binarySearch(_keys, key);
	}
	
	private byte insertEntry(int index, int key, byte value)
	{
		final int length = _keys.length;
		int[] tmpKeys = new int[length + 1];
		byte[] tmpValues = new byte[length + 1];
		if (index > 0) {
			System.arraycopy(_keys, 0, tmpKeys, 0, index);
			System.arraycopy(_values, 0, tmpValues, 0, index);
		}
		tmpKeys[index] = key;
		tmpValues[index] = value;
		int n;
		if ((n = length - index) > 0) {
			System.arraycopy(_keys, index, tmpKeys, index + 1, n);
			System.arraycopy(_values, index, tmpValues, index + 1, n);
		}
		_keys = tmpKeys;
		_values = tmpValues;
		return NULL;
	}
	
	public int keyAt(int index)
	{
		return _keys[index];
	}
	
	public byte valueAt(int index)
	{
		return _values[index];
	}
	
	public int getKey(int index)
	{
		return keyAt(index);
	}
	
	public byte getValue(int index)
	{
		return valueAt(index);
	}
	
	public byte setValue(int index, byte value)
	{
		byte prev = _values[index];
		_values[index] = value;
		return prev;
	}
	
	public void fill(byte value)
	{
		Arrays.fill(_values, value);
	}
	
	public void sort()
	{
		sort(0, _keys.length - 1);
	}
	
	private void sort(int left, int right)
	{
		if (left >= right) return;
		int pivot = _keys[(left + right) / 2];
		int i = left;
		int j = right;
		for (;;) {
			while (_keys[i] < pivot) ++i;
			while (pivot < _keys[j]) --j;
			if (i >= j) break;
			int key = _keys[i]; _keys[i] = _keys[j]; _keys[j] = key;
			byte value = _values[i]; _values[i] = _values[j]; _values[j] = value;
			++i;
			--j;
		}
		sort(left,  i - 1);
		sort(j + 1, right);
	}
}
