BarcodeBean.java

package fi.codecrew.moya.beans;

import java.io.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.BitSet;

import javax.ejb.EJB;
import javax.ejb.LocalBean;
import javax.ejb.Stateless;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.google.common.primitives.UnsignedBytes;

import fi.codecrew.moya.facade.PlaceFacade;
import fi.codecrew.moya.facade.PrintedCardFacade;
import fi.codecrew.moya.model.EventUser;
import fi.codecrew.moya.model.Place;
import fi.codecrew.moya.model.PrintedCard;
import fi.codecrew.moya.model.Product;
import fi.codecrew.moya.utilities.BarcodeUtils;

/**
 * Session Bean implementation class BarcodeBean
 */
@Stateless
@LocalBean
public class BarcodeBean implements BarcodeBeanLocal {

	private static final String PRINTED_CARD_BARCODEPREFIX = "277"; //2M
	private static final String EVENTUSER_BARCODEPREFIX = "279"; //2O
	private static final String PLACE_BARCODEPREFIX = "289"; //2Y
	
	private static final String PRINTED_CARD_TEXTCODEPREFIX = "10"; 
	private static final String PLACE_TEXTCODEPREFIX = "11"; 
	private static final String EVENTUSER_TEXTCODEPREFIX = "12"; 
	
	private static final String TEXTCODE_CHARACTER_MAP = "23456789ABCDEFGHJKLMNPQRSTUVWXYZ";
	private static final int  TEXTCODE_ROTATE_COUNT = 64; // 8*8
	
	//private static final String NEXT_PREFIX = "265";			//2A

	private static final Logger logger = LoggerFactory.getLogger(BarcodeBean.class);

	@EJB
	PrintedCardFacade printedCardFacade;

	@EJB
	PlaceFacade placeFacade;

	@EJB
	UserBeanLocal userBean;
	
	@EJB
	ProductBeanLocal productBean;
	

	/**
	 * Default constructor.
	 */
	public BarcodeBean() {
		// TODO Auto-generated constructor stub
	}

	public InputStream getUserBarcode(EventUser user) throws IOException {
		
		String barcode = generateBarcodeNumbers(EVENTUSER_BARCODEPREFIX, user.getId());
		
		logger.debug("Geneating barcode for user {} : {}", user, barcode);

		return BarcodeUtils.getBarcodeEAN(barcode);
	}

	public InputStream getCardBarcode(PrintedCard printedCard) throws IOException {
		
		String barcode = generateBarcodeNumbers(PRINTED_CARD_BARCODEPREFIX, printedCard.getId());
		
		logger.debug("Geneating barcode for card {} : {}", printedCard, barcode);

		return BarcodeUtils.getBarcodeEAN(barcode);
	}

	public String getPlaceTextCode(Place place) {
	
		String barcode = generateBarcodeNumbers(PLACE_TEXTCODEPREFIX, place.getId(), 8);
		
		BigInteger intCode;
		try {
			intCode = new BigInteger(barcode);
		} catch(NumberFormatException x)
		{
			return "GenFail";
		}
		
		String textCode = generateTextcode(intCode, 3);
		
		BigInteger checkCode = textcodeToNumber(textCode, 3);
		
		logger.debug("CheckCode {} : Original {}", checkCode, intCode);
		
		if(checkCode.compareTo(intCode) != 0) {
			logger.error("CheckCode {} : Original {}", checkCode, intCode);
			return "GenError"; // different error messages, so we can tell where the error was
		}

//		logger.debug("Geneating hexcode for place {} : {}", place.getId(), textCode);

		return textCode;
	}

	public String getVrAuthCodeForCard(PrintedCard printedCard) {
		StringBuilder sb = new StringBuilder();
		sb.append(PRINTED_CARD_BARCODEPREFIX);
		if (printedCard == null)
			return "";
		String idStr = printedCard.getId().toString();

		for (int i = 8 - idStr.length() - sb.length(); i > 0; --i) {
			sb.append("0");
		}
		sb.append(idStr);
		String code = sb.toString();

		String hexcode = Integer.toHexString(Integer.parseInt(code));
		String checksum = Integer.toHexString(hexcode.hashCode());
		checksum = checksum.substring(checksum.length() - 3);
		hexcode += checksum;
		//hexcode = Integer.toString(hexcode.hashCode());

		logger.debug("Geneating VrAuthcode for card {} : {}", printedCard.getId(), hexcode);

		return hexcode;
	}

	public String checkVrAuthCode(String code) {
		String checksumNew = code.substring(code.length() - 3);
		code = code.substring(0, (code.length() - 3));
		String checksumOld = Integer.toHexString(code.hashCode());
		checksumOld = checksumOld.substring(checksumOld.length() - 3);
		if (checksumNew.equals(checksumOld)) {
			int decimal = Integer.decode(code);
			code = Integer.toString(decimal);
			String prefix = code.substring(0, 2);
			int id = Integer.parseInt(code.substring(3, code.length() - 1));
			if (prefix.equals(PRINTED_CARD_BARCODEPREFIX) && id != 0) {
				PrintedCard printedCard = printedCardFacade.find(id);
				if (printedCard != null)
					return printedCard.getUser().getNick();
				else
					return "Invalid";
			}
		} else {
			return "Invalid";
		}
		return "Invalid";
	}

	@Override
	public Place getPlaceFromTextCode(String textcode) {

		BigInteger numbercode = textcodeToNumber(textcode, 3);
		String barcode = numbercode.toString();

		try {
			if (barcode.startsWith(PLACE_TEXTCODEPREFIX)) {
				int id = Integer.parseInt(barcode.substring(PLACE_TEXTCODEPREFIX.length(), barcode.length()));
				Place place = placeFacade.find(id);

				return place;
			}
		} catch (NumberFormatException x) {
		}

		return null;
	}

	public PrintedCard getPrintedCard(String barcode) {
		if (barcode == null || barcode.isEmpty())
			return null;

		// it's our special front barcode
		try {
			if (barcode.startsWith(PRINTED_CARD_BARCODEPREFIX)) {
				int id = Integer.parseInt(barcode.substring(3, barcode.length() - 1));
				PrintedCard card = printedCardFacade.find(id);

				if (card != null)
					return card;
			}
		} catch (NumberFormatException x) {
		}

		return printedCardFacade.findByCode(barcode);
	}

	public EventUser getUser(String barcode) {
		if (barcode == null || barcode.isEmpty())
			return null;

		// trim zeros off from barcode
		String stripped = barcode;
		while (stripped.length() > 0 && stripped.charAt(0) == '0') {
			stripped = stripped.substring(1);
		}

		if (stripped.length() > 0)
			barcode = stripped;

		try {
			// it's our special front barcode
			if (barcode.startsWith(EVENTUSER_BARCODEPREFIX)) {
				int id = Integer.parseInt(barcode.substring(3, barcode.length() - 1));
				logger.debug("finding user with barcode {} and id {}", barcode, id);
				EventUser user = userBean.findByEventUserId(id);

				return user;
			}
		} catch (NumberFormatException x) {
		}

		return null;
	}

	@Override
	public Product getProduct(String barcode) {
		return productBean.findByBarcode(barcode);
	}

	@Override
	public Place getPlaceFromBarcode(String barcode) {
		//throw new UnsupportedOperationException();
		return null;
	
		// TODO: tarttee hakea se paikkakoodi, ja sen avulla paikka. Toivon että se on ny tämä eikä placecodehäsmäkkä, mikä se oikeasti on. Vittu lisää refactorointia
	}
	
	private String generateBarcodeNumbers(String prefix, Integer id) {
		return generateBarcodeNumbers(prefix,id,12);
	}
	
	
	/**
	 * Reverse for generateTextcode
	 * @param original
	 * @param bytecount
	 * @return
	 */
	private BigInteger textcodeToNumber(String original, int bytecount) {
		

		BigInteger number = BigInteger.ZERO;
		BigInteger divnumber = BigInteger.valueOf(TEXTCODE_CHARACTER_MAP.length());
		int curExponent = 0;
		int curIndex = original.length() -1;
		do {
			
			char curChar = original.charAt(curIndex);
			BigInteger curNumber = BigInteger.valueOf(TEXTCODE_CHARACTER_MAP.indexOf(curChar));
			
			number = number.add(curNumber.multiply(divnumber.pow(curExponent++)));
			
		} while(--curIndex >= 0);
		
		BigInteger convertedNumber = new BigInteger(reverseLinearFeedbackShiftRegister(number.toByteArray(),bytecount, TEXTCODE_ROTATE_COUNT));
		
		
		return convertedNumber;
	}
	
	
	
	
	/**
	 * 
	 * @param original Original code to convert
	 * @param bytecount Code width in bytes
	 * @return
	 */
	private String generateTextcode(BigInteger original, int bytecount) {
		
	
		
		if(original == null || original.compareTo(BigInteger.ZERO) <= 0) {
			return "GenFail";
		}
		
		
		BigInteger numbersLeft = new BigInteger(linearFeedbackShiftRegister(original.toByteArray(),bytecount, TEXTCODE_ROTATE_COUNT)); 
		
		String converted = "";
		BigInteger divnumber = BigInteger.valueOf(TEXTCODE_CHARACTER_MAP.length());
		
		do {
			
			BigInteger div = numbersLeft.divide(divnumber);
			
			converted = TEXTCODE_CHARACTER_MAP.charAt(numbersLeft.subtract(div.multiply(divnumber)).intValue()) + converted;
			
			numbersLeft = div;
			
			if(numbersLeft.compareTo(divnumber) < 0) {
				converted = TEXTCODE_CHARACTER_MAP.charAt(numbersLeft.intValue()) + converted;
				numbersLeft = BigInteger.ZERO;
			}
			
		} while(numbersLeft.compareTo(BigInteger.ZERO) > 0);
		
		
		return converted;
	}
	
	private String generateBarcodeNumbers(String prefix, Integer id, int lenght) {
		StringBuilder sb = new StringBuilder();
		sb.append(prefix);
		String idStr = id.toString();

		for (int i = lenght - idStr.length() - sb.length(); i > 0; --i) {
			sb.append("0");
		}
		sb.append(idStr);
		return sb.toString();
	}

	
	
	
	/**
	 * http://en.wikipedia.org/wiki/Linear_feedback_shift_register
	 * 
	 * @param bytes bytes to rotate
	 * @param bytecount How many bytes we rotate from array, counting from right side
	 * @param times how many times we do lfsr-rotate
	 * @return rotated bytearray, this does not touch original array
	 */
	private byte[] reverseLinearFeedbackShiftRegister(byte[] bytes,int bytecount, int times) {
		
		
		// remove empty bytes from bytearray, this way this number wont bloat
		int emptySize = bytes.length - bytecount;
				
		if(emptySize < 0) emptySize = 0;

		
		byte[] convertedBytes = new byte[bytes.length - emptySize];
		
		int y = emptySize;
		for(int n = 0; n < convertedBytes.length; n++) {
			convertedBytes[n] = bytes[y++];
		}
		
		
		// empty part removed, let's do some lfsr-magic
		
		for(int n = 0; n < times; n++) {
			
			boolean curbit = (convertedBytes[0] & 0b10000000) != 0;
			
			
			curbit = curbit ^ ((convertedBytes[convertedBytes.length-1] & 0b10) != 0); // 2. bit from right
			curbit = curbit ^ ((convertedBytes[convertedBytes.length-1] & 0b100) != 0); // 3. bit from right
			curbit = curbit ^ ((convertedBytes[convertedBytes.length-1] & 0b10000) != 0); // 5. bit from right
			
			// sift left one
			for(int z = convertedBytes.length-1; z >= 0; z--) {
				boolean overflowBit = ((convertedBytes[z] & 0b10000000) != 0);
				
				convertedBytes[z] = (byte) (convertedBytes[z] << 1);
				
				if(curbit) {
					convertedBytes[z] = (byte) (convertedBytes[z] | 0b00000001);
				} else {
					convertedBytes[z] = (byte) (convertedBytes[z] & 0b11111110);
				}
				
				curbit = overflowBit;
			}
			
			
		}
		
		// add 1 zerobyte to the start, just to be sure that this number is now bigger than 0
		byte[] returnBytes = new byte[convertedBytes.length+1];
		
		for(int n = 0; n < convertedBytes.length; n++) {
			returnBytes[n+1] = convertedBytes[n];
		}
				
		
		return returnBytes;
	}
	
	
	
	
	/**
	 * http://en.wikipedia.org/wiki/Linear_feedback_shift_register
	 * 
	 * @param bytes bytes to rotate
	 * @param bytecount How many bytes we rotate from array, counting from right side
	 * @param times how many times we do lfsr-rotate
	 * @return rotated bytearray, this does not touch original array
	 */
	private byte[] linearFeedbackShiftRegister(byte[] bytes, int bytecount, int times) {
		
		
		// remove empty bytes from bytearray, this way this number wont bloat
		int emptySize = bytes.length - bytecount;
		
		if(emptySize < 0) emptySize = 0;
		
		byte[] convertedBytes = new byte[bytes.length - emptySize];
		
		int y = emptySize;
		for(int n = 0; n < convertedBytes.length; n++) {
			convertedBytes[n] = bytes[y++];
		}
		
		
		// empty part removed, let's do some lfsr-magic
		
		for(int n = 0; n < times; n++) {
			
			boolean curbit =  (convertedBytes[convertedBytes.length-1] & 0b1) != 0; // rightmost byte
			curbit = curbit ^ ((convertedBytes[convertedBytes.length-1] & 0b100) != 0); // 3. bit from right
			curbit = curbit ^ ((convertedBytes[convertedBytes.length-1] & 0b1000) != 0); // 4. bit from right
			curbit = curbit ^ ((convertedBytes[convertedBytes.length-1] & 0b100000) != 0); // 6. bit from right
			
			// sift right one
			for(int z = 0; z < convertedBytes.length; z++) {
				boolean overflowBit = ((convertedBytes[z] & 0b1) != 0);
				
				// >> uses leftmost bit as filler >>> uses 0 as filler
				convertedBytes[z] = (byte) (convertedBytes[z] >>> 1);
				
				if(curbit) {
					convertedBytes[z] = (byte) (convertedBytes[z] | 0b10000000);
				} else {
					convertedBytes[z] = (byte) (convertedBytes[z] & 0b01111111);
				}
				
				curbit = overflowBit;
			}
			
			
		}
		
		// add 1 zerobyte to the start, just to be sure that this number is now bigger than 0
		byte[] returnBytes = new byte[convertedBytes.length+1];
		
		for(int n = 0; n < convertedBytes.length; n++) {
			returnBytes[n+1] = convertedBytes[n];
		}
		
		return returnBytes;
		
	}

}