/*
    * 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.ods;
  
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.IOException;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.List;
  
  import olg.csv.base.AbstractSheetReader;
  import olg.csv.base.Cell;
  import olg.csv.base.Row;
  import olg.csv.bean.formatter.Formatter;
  
  import org.odftoolkit.odfdom.doc.OdfSpreadsheetDocument;
  import org.odftoolkit.odfdom.doc.table.OdfTable;
  import org.odftoolkit.odfdom.doc.table.OdfTableCell;
  import org.odftoolkit.odfdom.doc.table.OdfTableRow;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  import org.w3c.dom.Node;
  import org.w3c.dom.NodeList;
  
  /**
   * ODS Reader based on ODFDOM API.
   * 
   * @author Olivier Godineau
   * 
   */
  public class ODSReader extends AbstractSheetReader {
  	/**
  	 * The class logger.
  	 */
  	private static final Logger LOGGER = LoggerFactory.getLogger(ODSReader.class);
  	/**
  	 * The cell formatter.
  	 */
  	private final Formatter<OdfTableCell> cellFormatter;
  	/**
  	 * Indicate if the stream must be closed on close invocation.
  	 */
  	private boolean closeInputStream; // NOPMD by olivier on 08/01/12 18:20
  	/**
  	 * the stream.
  	 */
  	private final InputStream input;
  	/**
  	 * the ODS Document read from the stream.
  	 */
  	private OdfSpreadsheetDocument odfDocument;
  	/**
  	 * The sheet on which read.
  	 */
  	private OdfTable sheet;
  
  	/**
  	 * the nb of rows in the sheet.
  	 */
  	private int rowCount;
  
  	/**
  	 * 
  	 * @param odsFile
  	 *            the ODS File to read.
  	 * @param settings
  	 *            ods settings. If sheetname setting is defined try to find a
  	 *            sheet with this name otherwise try to read sheet at sheetNum
  	 *            position in sheets list. Must be not null and have a cell
  	 *            formatter.
  	 * @throws IOException
  	 *             if an error occurs during opening file,i.e the specified
  	 *             sheet has been not found
  	 */
  	public ODSReader(File odsFile, ODSSettings settings) throws IOException {
  		super(settings);
  		if (settings.getCellFormatter() == null) {
  			throw new IllegalArgumentException(
  					"ODSReader constructor ODSReaderSettings argument must have not null cellFormatter attribut");
  		}
  
  		this.input = new FileInputStream(odsFile);
  		this.closeInputStream = true;
  		this.cellFormatter = settings.getCellFormatter();
  		this.initSheet();
  	}
  
 	/**
 	 * 
 	 * @param input
 	 *            the stream to read.
 	 * @param settings
 	 *            ods settings. If sheetname setting is defined try to find a
 	 *            sheet with this name otherwise try to read sheet at sheetNum
 	 *            position in sheets list. Must be not null and have a cell
 	 *            formatter.
 	 * @throws IOException
 	 *             if an error occurs during opening file,i.e the specified
 	 *             sheet has been not found
 	 */
 	public ODSReader(InputStream input, ODSSettings settings) throws IOException {
 		super(settings);
 		if (input == null) {
 			throw new IllegalArgumentException("ODSReader constructor InputStream argument must not be null");
 		}
 		if (settings.getCellFormatter() == null) {
 			throw new IllegalArgumentException(
 					"ODSReader constructor ODSReaderSettings argument must have not null cellFormatter attribut");
 		}
 
 		this.input = input;
 		this.closeInputStream = false;
 		this.cellFormatter = settings.getCellFormatter();
 		this.initSheet();
 	}
 
 	@Override
 	protected void doOnInitSheet() throws IOException {
 		try {
 
 			this.odfDocument = OdfSpreadsheetDocument.loadDocument(input);
 			List<OdfTable> sheets = this.odfDocument.getTableList();
 			if (sheetName != null) {
 				for (OdfTable feuille : sheets) { // TODO à revoir
 					if (sheetName.equals(feuille.getTableName())) {
 						this.sheet = feuille;
 						this.sheetNum = sheets.indexOf(feuille);
 						break;
 					}
 				}
 				if (sheet == null) {
 					throw new IOException("Error on SpreadsheetDocument instanciation : no sheet[" + sheetName + "]");
 				}
 			} else {
 				try {
 					this.sheet = sheets.get(getSheetNum());
 					this.sheetName = this.sheet.getTableName();
 				} catch (IndexOutOfBoundsException ex) {
 					throw new IOException("Error on SpreadsheetDocument instanciation : no sheet at this index["
 							+ getSheetNum() + "]");
 				}
 			}
 
 			this.rowCount = sheet.getRowCount();
 		} catch (Exception e) {
 			close();
 			throw new IOException("Error on SpreadsheetDocument instanciation", e);
 		}
 
 	}
 
 	/**
 	 * Closes this stream and catch and logs IOException if necessary. if the
 	 * parent stream is provided and passed to ODSReader constructor by user,
 	 * user must close it (closes what you opens!)
 	 */
 	@Override
 	public void close() {
 		if (this.odfDocument != null) {
 			this.odfDocument.close();
 		}
 
 		if (closeInputStream && input != null) {
 			try {
 				input.close();
 			} catch (IOException ex) {
 				LOGGER.info("Error on closing ODSReader", ex);
 			}
 		}
 
 	}
 
 	@Override
 	protected Row setNext() {
 		Row retour = null;
 		List<Cell> cells = new ArrayList<Cell>();
 		int column = 0;
 		OdfTableRow odfRow = this.sheet.getRowByIndex(recordIndex - 1);
 
 		for (int i = 0; i < odfRow.getCellCount(); i++) {
 			OdfTableCell cell = odfRow.getCellByIndex(i);
 			String value = cellFormatter.toString(cell);
 			if (beginAtColumn > cell.getColumnIndex()) {
 				continue;
 			}
 			if (endAtColumn != null && endAtColumn < cell.getColumnIndex()) {
 				continue;
 			}
 			padding(cells, column, cell.getColumnIndex() - beginAtColumn);
 			cells.add(new Cell(cell.getColumnIndex() - beginAtColumn, ("".equals(value) ? null : value))); // NOPMD
 																											// by
 																											// olivier
 																											// on
 																											// 04/01/12
 																											// 23:26
 			column = cell.getColumnIndex() + 1 - beginAtColumn;
 		}
 		padding(cells, column, (endAtColumn == null ? rowSize : endAtColumn));
 
 		retour = new Row(recordIndex++, cells, rowSize);
 		return retour;
 	}
 
 	@Override
 	protected int getRows() {
 
 		return this.rowCount;
 	}
 
 	@Override
 	protected int defineRowSize() {
 
 		return this.sheet.getColumnCount();
 	}
 
 	/**
 	 * Define a default cell format strategy.
 	 * 
 	 * ODS Cell can use different ways to represent content on several lines : a
 	 * Cell could be composed with several paragraphs elements and each
 	 * paragraph could be composed with line-break elements. To format a cell as
 	 * a string, the default strategy is to extract paragraph content and use a
 	 * breakline string to separate them and replace in each paragraph element,
 	 * the line-break found element by a breakline. The breakline string used
 	 * must be defined at ODSCellFormatter instanciation.
 	 * 
 	 * @author Olivier Godineau
 	 * 
 	 */
 	public static final class ODSCellFormatter extends Formatter<OdfTableCell> {
 		/**
 		 * the breakline to use.
 		 */
 		private final String breakline;
 
 		/**
 		 * 
 		 * @param breakline
 		 *            to use
 		 */
 		public ODSCellFormatter(String breakline) {
 			super();
 			this.breakline = breakline;
 		}
 
 		@Override
 		public String toString(OdfTableCell cell) {
 			String value = null;
 			NodeList nodes = cell.getOdfElement().getChildNodes();
 			StringBuilder sbuild = new StringBuilder();
 
 			for (int j = 0; j < nodes.getLength(); j++) {
 				Node node = nodes.item(j);
 				NodeList childs = node.getChildNodes();
 				for (int i = 0; i < childs.getLength(); i++) {
 					Node child = childs.item(i);
 					String name = child.getNodeName();
 					String prefix = child.getPrefix();
 					if (name.equals(prefix + ":line-break")) {
 						sbuild.append(breakline);
 					} else {
 						sbuild.append(child.getTextContent());
 					}
 
 				}
 				sbuild.append(breakline);
 
 			}
 			if (nodes.getLength() > 0) {
 				value = sbuild.substring(0, sbuild.length() - breakline.length());
 			}
 			return value;
 		}
 
 	}
 
 }