/*
    * Copyright 2012 Olivier Godineau
    * 
    * 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 olg.csv.base;
  
  /**
   * Cell in a spreadsheet. Impoverished model to be conformed with use of CSV.
   * 
   * @author Olivier Godineau
   * @see Row
   */
  public class Cell {
  
  	/**
  	 * Reg Exp to validate num Cell format.
  	 */
  	private static final String FORMAT_NUM_REGEXP = "(:?[A-Z]+)|(:?\\d+)";
  
  	/**
  	 * NB alpha char.
  	 */
  	private static final int NB_CHAR = 26;
  	/**
  	 * A char as byte.
  	 */
  	private static final byte CHAR_A = 64;
  
  	/**
  	 * the cell num in its row.
  	 */
  	private final int num;
  	/**
  	 * The value of the cell.
  	 */
  	private final String value;
  
  	/**
  	 * Interprets the String in argument as a cell number. Two ways :
  	 * <ul>
  	 * <li>This argument is an non negative integer</li>
  	 * <li>this argument is a string in Sheet cell number format (as C, AB ,...</li>
  	 * </ul>
  	 * 
  	 * @param num
  	 *            the num cell. Must match one of the two cases see above.
  	 * @return the cell num as integer.
  	 * 
  	 */
  	public static int fromSheetCellNumber(String num) {
  		int retour;
  		if (num == null || !num.matches(FORMAT_NUM_REGEXP)) {
  			throw new IllegalArgumentException(String.format(
  					"fromSheetCellNumber argument num[%s] must match ([A-Z]+) regex " + "or be a non negative integer",
  					num));
  		}
  		if (num.matches("(:?\\d+)")) {
  			retour = Integer.parseInt(num);
  		} else {
  			retour = fromSheetFormatNumber(num);
  		}
  		return retour;
  	}
  
  	/**
  	 * Returns a num cell in a spreadsheet cell number format.
  	 * 
  	 * @param num
  	 *            . Must be >=0.
  	 * @return the num as a spreadsheet cell number
  	 */
  	public static String getSheetFormatNumber(int num) {
  		int curr = num + 1;
  		StringBuilder retour = new StringBuilder();
  		do {
  			int mod = curr % NB_CHAR;
  			mod = (mod == 0 ? NB_CHAR : mod);
  
  			retour.insert(0, ((char) (CHAR_A + mod)));
  			curr -= mod;
  
  		} while ((curr = curr / NB_CHAR) != 0);
  
  		return retour.toString();
  	}
  
  	/**
  	 * Returns the default cell name.
  	 * 
  	 * @param num
 	 *            the num of a cell.
 	 * @return the default cell name.
 	 */
 	public static String defaultCellName(String num) {
 		if (num == null || !num.matches(FORMAT_NUM_REGEXP)) {
 			throw new IllegalArgumentException(String.format(
 					"defaultCellName argument num[%s] must match ([A-Z]+) regex or be a non negative integer", num));
 		}
 		String cellNum = num;
 		if (num.matches("(:?\\d+)")) {
 			cellNum = getSheetFormatNumber(Integer.parseInt(num));
 		}
 		return "column_" + cellNum;
 	}
 	/**
 	 * 
 	 * @param num
 	 *            column number. Must be >= 0.
 	 * @param value
 	 *            cell value
 	 */
 	public Cell(int num, String value) {
 		super();
 		if (num < 0) {
 			throw new IllegalArgumentException(String.format(
 					"Cell constructor argument num[%s] must be a positive integer", num));
 		}
 		this.num = num;
 		this.value = value;
 	}
 
 	/**
 	 * 
 	 * @param num
 	 *            column number
 	 * @param value
 	 *            cell value
 	 */
 	public Cell(String num, String value) {
 		super();
 		this.num = Cell.fromSheetCellNumber(num);
 		this.value = value;
 	}
 
 	/**
 	 * Column number of this cell among parent row cells.
 	 * 
 	 * @return the cell num.
 	 */
 	public int getNum() {
 		return num;
 	}
 
 	/**
 	 * Returns the value of this cell.
 	 * 
 	 * @return <code>null</code> if this cell is empty.
 	 */
 	public String getValue() {
 		return value;
 	}
 
 	/**
 	 * Returns true if this cell represents an empty cell.
 	 * 
 	 * @return true if cell is empty.
 	 */
 	public boolean isEmpty() {
 		return value == null;
 	}
 
 	/**
 	 * Returns the column number of this cell in a spreadsheet format ( A for 0,
 	 * AA for 26, ...).
 	 * 
 	 * @return the column number in a sheet format.
 	 */
 	public String getSheetFormatNumber() {
 		return getSheetFormatNumber(num);
 	}
 
 	/**
 	 * Returns the couple (num: value) that this cell represents.
 	 * 
 	 * @return the cell string representation.
 	 */
 	public String toString() {
 		return "(" + num + ":" + value + ")";
 	}
 
 	@Override
 	public int hashCode() {
 		final int prime = 31; // NOPMD by olivier on 27/01/12 00:28
 		int result = 1;
 		result = prime * result + num;
 		return result;
 	}
 
 	@Override
 	public boolean equals(Object obj) {
 		boolean retour = true;
 		if (this != obj) {
 			if (obj == null || getClass() != obj.getClass()) {
 				retour = false;
 			} else {
 				retour = num != ((Cell) obj).num;
 			}
 		}
 
 		return retour;
 	}
 
 	/**
 	 * Returns the column number.
 	 * 
 	 * @param num
 	 *            column number in a spreadsheet format.
 	 * @return the column number.
 	 */
 	private static int fromSheetFormatNumber(final String num) {
 		int retour = 0;
 		int multi = 1;
 
 		char[] chars = num.toCharArray();
 		for (int i = chars.length - 1; i >= 0; i--) {
 			retour += multi * (((byte) chars[i] - CHAR_A));
 			multi *= NB_CHAR;
 		}
 
 		return retour - 1;
 	}
 }