/*
    * Copyright 2006 Christian Kalkhoff <me@ninan.info>
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *         http://www.apache.org/licenses/LICENSE-2.0
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package net.sf.plausj.bank.german;
  
  import net.sf.plausj.bank.german.strategy.Strategy;
  import net.sf.plausj.bank.german.util.StrategyHelper;
  import net.sf.plausj.bank.german.util.StrategyHelperImpl;
  
  /**
   * This is a german bank account object.
   * 
   * @author ninan
   * 
   */
  public class BankAccount {
  
  	/** Used internally to represent default value */
  	private static final int UNSET = 0;
  
  	/** No strategy is responsible for this bank account */
  	public static final int NOCHECK = 2;
  
  	/** All strategies said this bank account is valid */
  	public static final int VALID = 4;
  
  	/** All strategies said this bank account is invalid */
  	public static final int INVALID = 8;
  
  	/** Used to signal that the bank code was not found */
  	public static final int BANK_CODE_NOT_FOUND = 256;
  
  	/**
  	 * Used to signal that the strategy referenced by the bank code is not
  	 * implemented
  	 */
  	public static final int NOT_IMPLEMENTED = 512;
  
  	/** Some strategies said this bank account is valid, some said it is invalid */
  	public static final int AMBIGUOUS1 = VALID | INVALID;
  
  	/**
  	 * Some strategies said this bank account is valid, some said they are not
  	 * responsible
  	 */
  	public static final int AMBIGUOUS2 = VALID | NOCHECK;
  
  	/**
  	 * Some strategies said this bank account is invalid, some said they are not
  	 * responsible
  	 */
  	public static final int AMBIGUOUS3 = INVALID | NOCHECK;
  
  	/**
  	 * Some strategies said this bank account is valid, some said it is invalid
  	 * and some said they are not responsible
  	 */
  	public static final int AMBIGUOUS4 = VALID | INVALID | NOCHECK;
  
  	/** Stores the instance of the bank code */
  	private final BankCode bankCode;
  
  	/** Stores the instance of the account code */
  	private final AccountCode accountCode;
  
  	/** Stores the validity of the bank account */
  	private int validity = UNSET;
  
  	private final StrategyHelper sh = new StrategyHelperImpl();
  
  	/**
  	 * The default CTOR for a bank account.
  	 * 
  	 * @param bankCode
  	 *            The bank code of the account
  	 * @param accountCode
  	 *            The account code
  	 * @throws IllegalArgumentException
  	 *             If bank account or bank code are invalid this exception is
  	 *             thrown
  	 */
  	public BankAccount(final BankCode bankCode, final AccountCode accountCode)
  			throws IllegalArgumentException {
  
  		if (null == bankCode) {
  			throw new IllegalArgumentException(
 					"Null pointer supplied as bank code.");
 		}
 
 		if (null == accountCode) {
 			throw new IllegalArgumentException(
 					"Null pointer supplied as account code.");
 		}
 
 		this.bankCode = bankCode;
 		this.accountCode = accountCode;
 
 		calculateValidity();
 
 	}
 
 	/**
 	 * An comfort CTOR using strings instead of objects for bank code and
 	 * account code
 	 * 
 	 * @param bankCode
 	 *            The bank code of the account
 	 * @param accountCode
 	 *            The account code
 	 * @throws IllegalArgumentException
 	 *             If bank account or bank code are invalid this exception is
 	 *             thrown
 	 */
 	public BankAccount(final String bankCode, final String accountCode)
 			throws IllegalArgumentException {
 
 		this(new BankCode(bankCode), new AccountCode(accountCode));
 
 	}
 
 	/**
 	 * Returns the validity of this bank account. It returns an integer from the
 	 * range of the MAGICs in this class
 	 * 
 	 * @return The validity of the bank account
 	 * 
 	 * @see BankAccount#NOCHECK
 	 * @see BankAccount#VALID
 	 * @see BankAccount#INVALID
 	 * @see BankAccount#BLZ_NOT_FOUND
 	 * @see BankAccount#NOT_IMPLEMENTED
 	 * @see BankAccount#AMBIGUOUS1
 	 * @see BankAccount#AMBIGUOUS2
 	 * @see BankAccount#AMBIGUOUS3
 	 * @see BankAccount#AMBIGUOUS4
 	 */
 	public int getValidity() {
 		return validity;
 	}
 
 	/**
 	 * Return the validity as string constant
 	 * 
 	 * @return The validity as string
 	 */
 	public String getValidityAsString() {
 
 		if (UNSET == validity)
 			return "UNSET";
 
 		if (VALID == validity)
 			return "VALID";
 
 		if (INVALID == validity)
 			return "INVALID";
 
 		if (NOCHECK == validity)
 			return "NOCHECK";
 
 		if (BANK_CODE_NOT_FOUND == validity)
 			return "BANK_CODE_NOT_FOUND";
 
 		if (NOT_IMPLEMENTED == validity)
 			return "NOT_IMPLEMENTED";
 
 		if (AMBIGUOUS1 == validity)
 			return "AMBIGUOUS1";
 
 		if (AMBIGUOUS2 == validity)
 			return "AMBIGUOUS2";
 
 		if (AMBIGUOUS3 == validity)
 			return "AMBIGUOUS3";
 
 		if (AMBIGUOUS4 == validity)
 			return "AMBIGUOUS4";
 
 		return "UNKNOWN";
 
 	}
 
 	/**
 	 * @return Returns the accountCode.
 	 */
 	public AccountCode getAccountCode() {
 		return accountCode;
 	}
 
 	/**
 	 * @return Returns the bankCode.
 	 */
 	public BankCode getBankCode() {
 		return bankCode;
 	}
 
 	/**
 	 * Calculates the validity of the bank account
 	 * 
 	 */
 	private void calculateValidity() {
 
 		final Strategy[] strategies = sh.getStrategiesByBankCode(bankCode);
 
 		// There are no strategies for this bank code
 		if (null == strategies) {
 			validity = NOCHECK;
 			return;
 		}
 
 		for (int i = 0; i < strategies.length; ++i) {
 			Strategy s = strategies[i];
 			CheckDigit cd = s.calculateCheckDigit(bankCode, accountCode);
 
 			// The following lines set bits on the validity integer
 			if (null == cd) {
 				validity |= NOCHECK;
 				continue;
 			}
 
 			if (cd.isAlwaysValid()) {
 				validity |= VALID;
 				continue;
 			}
 
 			if (cd.isAlwaysInvalid()) {
 				validity |= INVALID;
 				continue;
 			}
 
 			if (cd.isBankCodeNotFound()) {
 				// Not an error, if bank code not found, there may be no other
 				// checks
 				validity = BANK_CODE_NOT_FOUND;
 				return;
 			}
 
 			if (cd.isNotImplemented()) {
 				// That míght be an bug or something, so we do an absolute thing
 				validity = NOT_IMPLEMENTED;
 				return;
 			}
 
 			if (accountCode.matchesCheckDigit(cd)) {
 				validity |= VALID;
 				continue;
 			} else {
 				validity |= INVALID;
 				continue;
 			}
 		}
 	}
 
 	/**
 	 * @see java.lang.Object#toString()
 	 */
 	public String toString() {
 		return "[BankCode='" + bankCode + "'; AccountCode='" + accountCode
 				+ "'; validity='" + getValidityAsString() + "(" + getValidity()
 				+ ")']";
 	}
 
 }