/*
    * 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.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  /**
   * Row in a spreadsheet. Impoverished model to be conformed to CSV.
   * 
   * @see IReader
   * @author Olivier Godineau
   * 
   */
  public class Row implements Iterable<Cell> {
  	/**
  	 * The number of this row among a row list.
  	 */
  	private final int num;
  	/**
  	 * Cells of this row. May be only contain cells which are no empty. Depends
  	 * on reader usage and its policy
  	 */
  	private final List<Cell> cells;
  
  	/**
  	 * number of cell (empties and no empty cells ).
  	 */
  	private final int size;
  
  	/**
  	 * 
  	 * @return true if row represents an empty row (all cells are empty).
  	 */
  	public boolean isEmpty() {
  		boolean retour = true;
  		if (!(cells == null || cells.isEmpty())) {
  
  			for (Cell cell : cells) {
  				if (!cell.isEmpty()) {
  					retour = false;
  					break;
  				}
  			}
  
  		}
  		return retour;
  	}
  
  	/**
  	 * Constructs a row with a num, cells and size.
  	 * 
  	 * @param num
  	 *            line number.Lines number begin at 1
  	 * @param cells
  	 *            the cells
  	 * @param size
  	 *            the row size. Must be >0.
  	 */
  	public Row(int num, List<Cell> cells, int size) {
  		super();
  		if (num < 1) {
  			throw new IllegalArgumentException(String.format(
  					"Row constructor argument num[%s] must be a positive integer", num));
  		}
  		if (size <= 0) {
  			throw new IllegalArgumentException(String.format(
  					"Row constructor argument size[%s] must be a not null positive integer", size));
  		}
  
  		this.num = num;
  		if (cells == null) {
  			this.cells = new ArrayList<Cell>(0);
  		} else {
  			this.cells = cells;
  		}
  
  		this.size = size;
  
  		// TODO valider la liste de cells
  
  	}
  
  	/**
  	 * Return the number of the row among the target document lines.
  	 * 
  	 * @return the row num.
 	 */
 	public int getNum() {
 		return num;
 	}
 
 	/**
 	 * The size of this Row corresponding to the number of cells (empty and no
 	 * empty). can differ from getCells().size() depending on the chosen option
 	 * at reading or at writing.
 	 * 
 	 * @return the row size.
 	 */
 	public int getSize() {
 		return size;
 	}
 
 	/**
 	 * Cells iterator. Only iterate registered cells in this row.
 	 * 
 	 * @return a cells iterator.
 	 */
 	public Iterator<Cell> iterator() {
 		return cells.iterator();
 	}
 
 	/**
 	 * Returns registered Cell which has the given num.
 	 * 
 	 * @param num
 	 *            num of the cell. Must be < row size.
 	 * @return <code>null</code> if no cell found with the given num
 	 */
 	public Cell getCell(int num) {
 		Cell retour = null;
 		if (num >= size) {
 			throw new IllegalArgumentException(String.format("num argument[%s] must be lesser than row size[%s]", num,
 					size));
 		}
 
 		for (Cell cell : cells) {
 			if (cell.getNum() == num) {
 				retour = cell;
 				break;
 			}
 		}
 		return retour;
 	}
 
 	/**
 	 * Return cell at the specific number from this row.
 	 * 
 	 * @param num
 	 *            Must be in a sheet cell number format (as A, B, C, ...,
 	 *            AB,...) or a non negative integer
 	 * @return <code>null</code> if no cell found with the given num.
 	 * @see Cell#fromSheetCellNumber(String)
 	 */
 	public Cell getCell(final String num) {
 		final int cellNumber = Cell.fromSheetCellNumber(num);
 
 		return getCell(cellNumber);
 
 	}
 
 	/**
 	 * Returns a representation of this row like
 	 * {num:num,size:size,cells:cells}.
 	 * 
 	 * @return the string representation.
 	 */
 	public String toString() {
 		return new StringBuilder().append("{num:").append(num).append(",size:").append(size).append(",cells:")
 				.append(cells.toString()).append("}").toString();
 	}
 
 	/**
 	 * Create a copy with its size and cells.
 	 * 
 	 * @param num
 	 *            the num of the row
 	 * @return the row
 	 */
 	public Row copy(int num) {
 		return new Row(num, cells, size);
 	}
 }