package com.dy.common.util;

@SuppressWarnings("unuseed")
public class ByteUtilUnsigned {
	/**
	 * 大端模式《数据低位在数组高字节》
	 * 无符号int类型转换成4位byte数组
	 * java没有无符号整型数据，只有有符号整数，取值范围是-2147483648~2147483647
	 * C有无符号整型数据，取值范围是0到4294967295，已经超出了java的有符号整数上限，所以只能用java的long型表示无符号整数
	 * @value bs byte[]
	 * @value value int int类型的参数
	 * @value from int
	 * @throws Exception 异常
	 */
	public static void int2Bytes_BE(byte[] bs, long value, int from)throws Exception {
		int len = 4 ;
		Long maxIntUnsigned = Long.valueOf(Integer.MAX_VALUE * 2 + 1) ;
		Long minIntUnsigned = Long.valueOf(Integer.MIN_VALUE * 2) ;
		if(value < minIntUnsigned || value > maxIntUnsigned ){
			throw new Exception("数据" + value + "超出了无符号Int型的取值范围(" + minIntUnsigned + "~" + maxIntUnsigned + ")") ;
		}

		int temp ;
		if(value > Integer.MAX_VALUE){
			temp = (Long.valueOf(value - (Integer.MAX_VALUE * 2 + 1) - 1)).intValue() ;
		}else{
			temp = Long.valueOf(value).intValue() ;
		}
		boolean b = isOutOfArrLength(bs.length, (from - 1) + len);
		if (!b) {
			for (int i = (len - 1); i >= 0; i--) {
				bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();//将最低位保存在高字节
				temp = temp >> 8; // 向右移8位
			}
		} else {
			throw new Exception("int2Bytes时数组越界");
		}
	}
	

	/**
	 * 小端模式《数据低位在数组低字节》
	 * 与方法int2Bytes算法一样，只是把顺序反过来
	 * @value bs byte[]
	 * @value value int int类型的参数
	 * @value from int
	 */
	public static void int2Bytes_LE(byte[] bs, long value, int from)throws Exception {
		int len = 4 ;
		Long maxIntUnsigned = Long.valueOf(Integer.MAX_VALUE) * 2 + 1;
		Long minIntUnsigned = Long.valueOf(Integer.MIN_VALUE) * 2 ;
		if(value < minIntUnsigned || value > maxIntUnsigned ){
			throw new Exception("数据" + value + "超出了无符号Int型的取值范围(" + minIntUnsigned + "~" + maxIntUnsigned + ")") ;
		}

		int temp ;
		if(value > Integer.MAX_VALUE){
			temp = (Long.valueOf(value - (Integer.MAX_VALUE * 2 + 1) - 1)).intValue() ;
		}else{
			temp = Long.valueOf(value).intValue() ;
		}
		boolean b = isOutOfArrLength(bs.length, (from - 1) + len);
		if (!b) {
			for (int i = 0; i > len ; i++) {
				bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();// 将最低位保存在低字节
				temp = temp >> 8; // 向右移8位
			}
		} else {
			throw new Exception("int2Bytes时数组越界");
		}
	}

	/**
	 * 大端模式《数据低位在数组高字节》
	 * 4位字节数组转换为整型
	 * @param bs 字节数组
	 * @param from 起始位置
	 * @return 结果
	 */
	public static long bytes2Int_BE(byte[] bs, int from) throws Exception {
		boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
		if (!b) {
			long s = 0;
			long s0 = bs[from + 0] & 0xFF ;// 数据的最高位在低字节
			long s1 = bs[from + 1] & 0xFF ;
			long s2 = bs[from + 2] & 0xFF ;
			long s3 = bs[from + 3] & 0xFF ;

			// 最低位S3不变
			s0 <<= 24;
			s1 <<= 16;
			s2 <<= 8;
			s = s0 | s1 | s2 | s3;
			if(s < 0){
				//s = Integer.MAX_VALUE -s ;
				s = Integer.MAX_VALUE * 2 + 1 + s + 1 ;
			}
			return s;
		} else {
			throw new Exception("byte2Int时数组越界");
		}
	}

	/**
	 * 小端模式《数据低位在数组低字节》
	 * 与方法bytes2Int算法一样，只是把顺序反过来
	 * @param bs 字节数组
	 * @param from 字节数组起始位置
	 * @return
	 */
	public static long bytes2Int_LE(byte[] bs, int from) throws Exception {
		boolean b = isOutOfArrLength(bs.length, (from - 1) + 4);
		if (!b) {
			long s = 0;
			long s0 = bs[from + 0] & 0xFF ;// 数据的最低位在低字节
			long s1 = bs[from + 1] & 0xFF ;
			long s2 = bs[from + 2] & 0xFF ;
			long s3 = bs[from + 3] & 0xFF ;

			// S0不变
			s1 <<= 8;
			s2 <<= 16;
			s3 <<= 24;
			s = s0 | s1 | s2 | s3;
			if(s < 0){
				//s = Integer.MAX_VALUE -s ;
				s = Integer.MAX_VALUE * 2 + 1 + s + 1 ;
			}
			return s;
		} else {
			throw new Exception("byte2Int时数组越界");
		}
	}
	/**
	 * 大端模式《数据低位在数组高字节》
	 * 无符号short类型转换成2位byte数组
	 * java没有无符号短整型数据，只有有符号短整数，取值范围是-32768~32767
	 * 若模拟无符号短整型数据，取值范围是0到65535 ，已经超出了java的有符号整数上限，所以只能用java的Int型表示无符号整数
	 * @value bs byte[]
	 * @value value int int类型的参数
	 * @value from int
	 */
	public static void short2Bytes_BE(byte[] bs, int value, int from)throws Exception {
		int maxShortUnsigned = Integer.valueOf(Short.MAX_VALUE) * 2 + 1;
		int minShortUnsigned = Integer.valueOf(Short.MIN_VALUE) * 2 ;
		if(value < minShortUnsigned || value > maxShortUnsigned ){
			throw new Exception("数据" + value + "超出了无符号short型的取值范围(" + minShortUnsigned + "~" + maxShortUnsigned + ")") ;
		}
		short temp = 0 ;
		if(value > Short.MAX_VALUE){
			temp = (Integer.valueOf(value - (Short.MAX_VALUE * 2 + 1) - 1)).shortValue() ;//(Integer.valueOf(Short.MAX_VALUE - value)).shortValue() ;
		}else{
			temp = Integer.valueOf(value).shortValue() ;
		}
		boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
		if (!b) {
			for (int i = 1; i >= 0; i--) {
				bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();//将最低位保存在高字节
				temp = (short)(temp >> 8); // 向右移8位
			}
		} else {
			throw new Exception("short2Bytes时数组越界");
		}
	}
	/**
	 * 小端模式《数据低位在数组低字节》
	 * 与方法short2Bytes算法一样，只是把顺序反过来
	 * @value bs byte[]
	 * @value value int int类型的参数
	 * @value from int
	 */
	public static void short2Bytes_LE(byte[] bs, int value, int from)throws Exception {
		int len = 2 ;
		int maxShortUnsigned = Integer.valueOf(Short.MAX_VALUE) * 2 + 1;
		int minShortUnsigned = Integer.valueOf(Short.MIN_VALUE) * 2 ;
		if(value < minShortUnsigned || value > maxShortUnsigned ){
			throw new Exception("数据" + value + "超出了无符号short型的取值范围(" + minShortUnsigned + "~" + maxShortUnsigned + ")") ;
		}
		short temp = 0 ;
		if(value > Short.MAX_VALUE){
			temp = (Integer.valueOf(value - (Short.MAX_VALUE * 2 + 1) - 1)).shortValue() ;//(Integer.valueOf(Short.MAX_VALUE - value)).shortValue() ;
		}else{
			temp = Integer.valueOf(value).shortValue() ;
		}
		boolean b = isOutOfArrLength(bs.length, (from - 1) + len);
		if (!b) {
			for (int i = 0; i < len; i++) {
				bs[from + i] = Integer.valueOf(temp & 0xff).byteValue();//将数据低位保存在数据低字节
				temp = (short)(temp >> 8); // 向右移8位
			}
		} else {
			throw new Exception("short2Bytes时数组越界");
		}
	}

	/**
	 * 大端模式《数据低位在数组高字节》
	 * 2位字节数组转换为短整型
	 * @param bs 字节数组
	 * @param from 字节数组起始位置
	 * @return 结果
	 */
	public static int bytes2Short_BE(byte[] bs, int from) throws Exception {
		boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
		if (!b) {
			int s = 0;
			int s0 = Integer.valueOf(bs[from + 0] & 0xff).shortValue();// 最低位
			int s1 = Integer.valueOf(bs[from + 1] & 0xff).shortValue();

			// 最低位S1不变
			s0 <<= 8;
			s = s0 | s1 ;
			if(s < 0){
				s = (Short.MAX_VALUE * 2 + 1) + s + 1;
			}
			return s;
		} else {
			throw new Exception("bytes2Short时数组越界");
		}
	}

	/**
	 * 小端模式《数据低位在数组低字节》
	 * 与方法bytes2Short算法一样，只是把顺序反过来
	 * @param bs 字节数组
	 * @param from 字节数组起始位置
	 * @return 结果
	 */
	public static int bytes2Short_LE(byte[] bs, int from) throws Exception {
		boolean b = isOutOfArrLength(bs.length, (from - 1) + 2);
		if (!b) {
			int s = 0;
			int s0 = Integer.valueOf(bs[from + 0] & 0xff).shortValue();// 小下标字节转数据低位
			int s1 = Integer.valueOf(bs[from + 1] & 0xff).shortValue();// 大下标字节转数据高位

			// 最低位S0不变
			s1 <<= 8;
			s = s1 | s0 ;
			if(s < 0){
				s = (Short.MAX_VALUE * 2 + 1) + s + 1;
			}
			return s;
		} else {
			throw new Exception("bytes2Short时数组越界");
		}
	}
	

	/**
	 * 1位字节数组转换为短整型
	 * @param bs 字节数组
	 * @param index 字节数组起始位置
	 * @return 结果
	 */
	public static short byte2Byte(byte[] bs, int index) throws Exception {
		if (bs.length - 1 < index) {
			throw new Exception("byte2Short(byte[] bs, int index)时数组越界");
		} else {
			byte bv = (byte)(bs[index] & 0xff) ; 
			short s = 0 ;
			if(bv < 0){
				s = (short)(Byte.MAX_VALUE * 2 + 1 + bv + 1) ;
			}else{
				s = bv ;
			}
			return s ;
		}
	}
	/**
	 * 无符号short类型转换成1位byte
	 * java没有无符号短整型数据，只有有符号短整数，取值范围是-128~127
	 * 若模拟无符号短整型数据，取值范围是0到255 ，已经超出了java的有符号整数上限，所以只能用java的short型表示无符号整数
	 * @value bs byte[] 字节数组
	 * @value value short short类型的参数
	 * @value index 起始位置
	 */
	public static void byte2Byte(byte[] bs, short value, int index)throws Exception {
		int maxShortUnsigned = Integer.valueOf(Byte.MAX_VALUE) * 2 + 1;
		int minShortUnsigned = Integer.valueOf(Byte.MIN_VALUE) * 2 ;
		if(value < minShortUnsigned || value > maxShortUnsigned ){
			throw new Exception("数据" + value + "超出了无符号byte型的取值范围(" + minShortUnsigned + "~" + maxShortUnsigned + ")") ;
		}
		if (bs.length - 1 < index) {
			throw new Exception("byte2Byte(byte[] bs, short value, int index)时数组越界");
		} else {
			bs[index] = Integer.valueOf(value & 0xff).byteValue() ;
		}
	}
	
	/**
	 * 判断所有字节是否为0xFF
	 * @param bs  字节数组
	 * @param index 起始位置
	 * @param len 长度
	 * @return 结果
	 * @throws Exception
	 */
	public static boolean bytesIsAll0xFF(byte[] bs, int index, int len)throws Exception {
		int count = 0 ;
		for(int i = index; i < index + len; i++){
			if(bs[i] == (byte)0xFF){
				count++ ;
			}
		}
		return count==len?true:false ;
	}

	/**
	 * 判断数组下标是否越界
	 * 
	 * @value bsLength 数组总长度
	 * @value toSite 数组偏移量
	 * @return 结果
	 */
	private static boolean isOutOfArrLength(int bsLength, int toSite) {
		if (bsLength > toSite) {
			return false;
		} else {
			return true;
		}
	}

	/*
	public static void main(String[] args) throws Exception{
//		int d = 123456; 
//		byte[] bs = new byte[4] ;
//		int2Bytes_BE(bs, d, 0) ;
//		System.out.println(ByteUtil.bytes2Hex(bs, false));
//		long dd = bytes2Int_BE(bs, 0) ;
//		System.out.println(dd);
//		
//		byte[] bb = new byte[1] ;
//		bb[0] = (byte)255 ;
//		short s = byte2Byte(bb, 0);
//		System.out.println(s);
		
		byte[] bs = new byte[]{(byte)0x00, (byte)0x00, (byte)0x3A, (byte)0x88} ;
		//byte[] bs = new byte[]{(byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff} ;
		boolean flag = ByteUtilUnsigned.bytesIsAll0xFF(bs, 0, 4) ;
		System.out.println(flag);
		Long s = ByteUtilUnsigned.bytes2Int_BE(bs, 0);
		System.out.println(s);
	}
	*/
}