/*
    * 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;
  import java.io.IOException;
  import java.util.List;
  import java.util.NoSuchElementException;
  
  /**
   * Abstract class which embeds sheet reader characteristics.
   * 
   * @author Olivier Godineau
   * 
   * 
   */
  public abstract class AbstractSheetReader implements IReader {
  	/**
  	 * Indicate if emtpy cells are skipping.
  	 */
  	protected boolean skipEmptyCell = false;
  	/**
  	 * the sheet num. 0 is the first.
  	 */
  	protected int sheetNum;
  	/**
  	 * Record index. first is 1.
  	 */
  	protected int recordIndex = 1;
  	/**
  	 * Record size.
  	 */
  	protected int rowSize = 0;
  
  	/**
  	 * Sheet name.
  	 */
  	protected String sheetName = null;
  
  	/**
  	 * Indicate if an header row must be skipped.
  	 */
  	protected boolean withHeaders;
  	/**
  	 * First row to read.
  	 */
  	protected Integer beginAtRow = 1;
  	/**
  	 * last row to read.
  	 */
  	protected Integer endAtRow = null;
  
  	/**
  	 * First cell to read in each row.
  	 */
  	protected Integer beginAtColumn = 0;
  	/**
  	 * Last cell to read in each row.
  	 */
  	protected Integer endAtColumn = null;
  
  	/**
  	 * {@inheritDoc}
  	 */
  	public final boolean hasNext() {
  		return getRows() >= recordIndex && (endAtRow == null ? true : endAtRow >= recordIndex);
  	}
  
  	/**
  	 * {@inheritDoc}
  	 */
  	public final Row next() {
  		if (!hasNext()) {
  			throw new NoSuchElementException();
  		}
  		return setNext();
  
  	}
  
  	/**
  	 * Unsupported Operation. Throw UnsupportedOperationException
  	 */
  	public final void remove() {
  		throw new UnsupportedOperationException();
  
  	}
  
  	/**
  	 * {@inheritDoc}
  	 */
 	public boolean isWithHeaders() {
 		return this.withHeaders;
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public abstract void close();
 
 	/**
 	 * Returns the next Row.
 	 * 
 	 * @return the next row.
 	 */
 	protected abstract Row setNext();
 
 	/**
 	 * Method called by {@link #initSheet()} to allow concret SheetReader to do
 	 * some stuff on its instanciation.
 	 * 
 	 * @throws IOException
 	 *             if I/O error occurs.
 	 */
 	protected abstract void doOnInitSheet() throws IOException;
 
 	/**
 	 * Complete cell lists in parameter with empty cells.
 	 * 
 	 * @param cells
 	 *            list to complete
 	 * @param columnBegin
 	 *            index colum from which begins the padding (inclusive)
 	 * @param columnEnd
 	 *            index column to which ends the padding (exclusive).
 	 * @return the completed list
 	 */
 	protected List<Cell> padding(List<Cell> cells, int columnBegin, int columnEnd) {
 		if (!skipEmptyCell) {
 			for (int j = columnBegin; j < columnEnd; j++) {
 				cells.add(new Cell(j, null)); // NOPMD by olivier on 27/01/12
 												// 00:32
 			}
 		}
 		return cells;
 	}
 
 	/**
 	 * Returns the index of the current sheet this reader has opened.
 	 * 
 	 * @return the index.
 	 */
 	public int getSheetNum() {
 		return sheetNum;
 	}
 	/**
 	 * Returns sheet name corresponding to the sheet this reader has opened.
 	 * 
 	 * @return the sheet name
 	 */
 	public String getSheetName() {
 		return sheetName;
 	}
 
 	/**
 	 * Get the row count of this sheet.
 	 * 
 	 * @return total count of rows
 	 */
 	protected abstract int getRows();
 
 	/**
 	 * Method to call by concret constructor to initialize some stuff. By
 	 * default, skip headers if specified, and define row size. If redefined by
 	 * concret child class, initSheet must call parent initSheet to guaranty
 	 * correct initialization
 	 * 
 	 * @throws IOException
 	 *             if I/O error occurs during initialization.
 	 * 
 	 * @see #doOnInitSheet()
 	 */
 	protected void initSheet() throws IOException {
 		doOnInitSheet();
 		this.rowSize = defineRowSize();
 
 	}
 
 	/**
 	 * Returns the expected rows length of each line.
 	 * 
 	 * @return the rows size.
 	 */
 	protected abstract int defineRowSize();
 
 	/**
 	 * Check and set parameters.
 	 * <p>
 	 * Throws IllegalArgumentException if one of these parameters.
 	 * </p>
 	 * 
 	 * @param beginAtRow
 	 *            the row index from which begins the reading. lines number
 	 *            begin at 1
 	 * @param endAtRow
 	 *            the last index to which ends the reading.
 	 * @param beginAtColumn
 	 *            the cell num from which begins the row reading. columns begin
 	 *            at 0. Could be in sheet cell format or a number.
 	 * @param endAtColumn
 	 *            the cell num to which ends the row reading. Could be null.
 	 */
 	private void checkParameters(Integer beginAtRow, Integer endAtRow, String beginAtColumn, String endAtColumn) {
 		if (beginAtRow != null) {
 			this.beginAtRow = beginAtRow;
 			if (this.beginAtRow < 1) {
 				throw new IllegalArgumentException("SheetReader Constructor settings argument: beginAtRow parameter["
 						+ beginAtRow
 						+ "] must be a positive number  or null (in this case reading begins at the first row)");
 
 			}
 		}
 
 		if (endAtRow != null) {
 			this.endAtRow = endAtRow;
 
 			if (this.endAtRow < 1 || this.endAtRow <= this.beginAtRow) {
 				throw new IllegalArgumentException("SheetReader Constructor settings argument endAtRow parameter["
 						+ endAtRow + "] must be a positive number and be greater than " + this.beginAtRow
 						+ " or null(in this case reading ends at the last row)");
 			}
 		}
 
 		if (beginAtColumn != null) {
 			try {
 				this.beginAtColumn = Cell.fromSheetCellNumber(beginAtColumn);
 			} catch (IllegalArgumentException ex) {
 				throw new IllegalArgumentException(
 						"SheetReader Constructor settings argument: beginAtColumn parameter[" + beginAtColumn
 								+ "] must be a positive number greater "
 								+ "than 0 or an expression conformed to spreadsheet column Notation or "
 								+ "null(in this case rows reading begins at the first column)", ex);
 			}
 
 		}
 
 		if (endAtColumn != null) {
 			try {
 				this.endAtColumn = Cell.fromSheetCellNumber(endAtColumn);
 			} catch (IllegalArgumentException ex) {
 				throw new IllegalArgumentException("SheetReader Constructor settings argument: endAtColumn parameter["
 						+ endAtColumn + "] must be a positive number greater than 0 or an expression conformed "
 						+ "to spreadsheet column Notation "
 						+ "or null (in this case rows reading ends at the last column", ex);
 			}
 
 			if (this.endAtColumn <= this.beginAtColumn) {
 				throw new IllegalArgumentException("SheetReader Constructor settings argument: endAtColumn parameter["
 						+ endAtColumn + "] must be greater than " + (beginAtColumn == null ? "A" : beginAtColumn));
 			}
 		}
 	}
 
 	/**
 	 * 
 	 * @param settings
 	 *            the reader settings. Must not be <code>null</code>.
 	 */
 	public AbstractSheetReader(AbstractSheetSettings<? extends AbstractSheetSettings<?>> settings) {
 		super();
 		if (settings == null) {
 			throw new IllegalArgumentException("SheetReader Constructor settings argument must not be null");
 		}
 		checkParameters(settings.getBeginAtRow(), settings.getEndAtRow(), settings.getBeginAtColumn(),
 				settings.getEndAtColumn());
 		this.withHeaders = settings.isWithHeaders();
 		this.sheetNum = settings.getSheetNum();
 		this.sheetName = settings.getSheetName();
 
 		this.recordIndex = this.beginAtRow;
 
 	}
 
 }