/*
    * 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.IOException;
  import java.io.OutputStream;
  import java.util.ArrayList;
  import java.util.List;
  
  import olg.csv.base.AbstractSheetWriter;
  import olg.csv.base.Cell;
  import olg.csv.base.Row;
  import olg.csv.base.WriterException;
  import olg.csv.bean.parser.AbstractParser;
  import olg.csv.bean.parser.ParseException;
  
  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.odftoolkit.odfdom.incubator.doc.text.OdfTextParagraph;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  /**
   * ODS Writer based on ODFDOM API.
   * 
   * @author Olivier Godineau
   * 
   */
  public class ODSWriter extends AbstractSheetWriter {
  	/**
  	 * Class logger.
  	 */
  	private static final Logger LOGGER = LoggerFactory.getLogger(ODSWriter.class);
  	/**
  	 * the ODS Document.
  	 */
  	private OdfSpreadsheetDocument outputDocument = null;
  	/**
  	 * the table on which write rows.
  	 */
  	private OdfTable table = null;
  	/**
  	 * the out file.
  	 */
  	private File outFile = null;
  	/**
  	 * the out stream.
  	 */
  	private OutputStream out = null;
  	/**
  	 * The cell parser.
  	 */
  	private final AbstractParser<List<String>> cellParser;
  	/**
  	 * the size of the rows to add in the document.
  	 */
  	private int size;
  	/**
  	 * the current row index to add.
  	 */
  	private int currentLine = 1;
  
  	/**
  	 * Indicates if document cells must be emptied. Useful when cells of a row
  	 * to add do not follow.
  	 */
  	private final boolean emptyingCell;
  
  	/**
  	 * Indicates if document rows must be emptied. useful when the rows to add
  	 * do not follow.
  	 */
  	private final boolean emtpyingRow;
  
  	/**
  	 * Indicates if the document must be overriding. true if the table was not
  	 * created but opened in an existing document.
  	 */
  	private boolean overridding = false;
  
  	/**
  	 * 
  	 * @param outFile
  	 *            if outFile exists and contains sheet with specified sheetName,
  	 *            rewrites rows and cells in it. if sheetname sheet doesn't
 	 *            exists, creates it and writes on it. If outFile not exists,
 	 *            creates a new ODS File.
 	 * @param settings
 	 *            the ODS Settings
 	 * @throws IOException
 	 *             if an errors occurs on file opening.
 	 */
 	public ODSWriter(File outFile, ODSSettings settings) throws IOException {
 		super(settings);
 		if (outFile == null) {
 			throw new IllegalArgumentException("ODSWriter constructor File argument must not be null");
 		}
 
 		if (settings.getStringParser() == null) {
 			throw new IllegalArgumentException(
 					"ODSWriter constructor ODSSettings argument must have not null StringParser attribut");
 		}
 		this.outFile = outFile;
 		this.cellParser = settings.getStringParser();
 		this.emptyingCell = settings.isEmptyingCell();
 		this.emtpyingRow = settings.isEmptyingRow();
 
 		if (this.outFile.isFile()) {
 			loadDocument(sheetName);
 		} else {
 			createNewDocument(sheetName);
 		}
 
 	}
 
 	/**
 	 * Constructs ODSWriter with outputStream and Settings. Try to create a new
 	 * ODS Document which will be saved
 	 * 
 	 * @param out
 	 *            writes a new ODSDocument on it.
 	 * @param settings
 	 *            ODS Settings
 	 * @throws IOException
 	 *             if unable to create a new ODS Document
 	 */
 	public ODSWriter(OutputStream out, ODSSettings settings) throws IOException {
 		super(settings);
 		if (out == null) {
 			throw new IllegalArgumentException("ODSWriter constructor out argument must not be null");
 		}
 		if (settings.getStringParser() == null) {
 			throw new IllegalArgumentException(
 					"ODSWriter constructor ODSSettings argument must have not null StringParser attribut");
 		}
 
 		this.out = out;
 		this.cellParser = settings.getStringParser();
 		this.emptyingCell = settings.isEmptyingCell();
 		this.emtpyingRow = settings.isEmptyingRow();
 
 		try {
 			createNewDocument(sheetName);
 		} catch (Exception e) {
 			LOGGER.debug("Unable to create ODS Document", e);
 			throw new IOException("Unable to create ODS Document", e);
 		}
 	}
 
 	/**
 	 * Close this stream and save the ODS Document to the file/stream and catch
 	 * and log Exception if necessary. if the parent stream is provided and
 	 * passed to its constructor by user, user must close it (close what you
 	 * open!).
 	 */
 	public void close() {
 		if (outputDocument != null) {
 			try {
 				if (outFile != null) {
 					outputDocument.save(outFile);
 				}
 				if (out != null) {
 					outputDocument.save(out);
 				}
 			} catch (Exception e) {
 				LOGGER.info("Error on closing ODSWriter : Unable to save ODS file " + outFile, e);
 			} finally {
 				outputDocument.close();
 			}
 		}
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public void addRow(Row row) {
 		if (row == null) {
 			throw new IllegalArgumentException("ODSWriter#addRow argument must not be null");
 		}
 		if (row.getNum() < currentLine) {
 			throw new WriterException(String.format("Row num[%s] but %s was expected or superior", row.getNum(),
 					currentLine));
 		}
 		if (size == 0) {
 			size = row.getSize(); // when this is first line
 		}
 		if (size != row.getSize()) {
 			throw new WriterException(String.format("Row size[%s] differs from the expected size[%s] ", row.getSize(),
 					size));
 		}
 
 		emptyRows(row.getNum());
 
 		OdfTableRow odfRow = table.getRowByIndex(row.getNum() + beginAtRow - 2);
 
 		int column = 0;
 		for (Cell cell : row) {
 			if (cell.getNum() < column) {
 				throw new WriterException("ODSWriter#addRow cells must be ordered ");
 			}
 
 			emptyCells(odfRow, column, cell.getNum(), false);
 
 			insertCell(odfRow, cell);
 			column = cell.getNum() + 1;
 		}
 
 		emptyCells(odfRow, column, size, false);
 
 		currentLine = row.getNum() + 1;
 
 	}
 
 	/**
 	 * {@inheritDoc}
 	 */
 	public void addLine(String[] values) {
 		if (values == null || values.length == 0) {
 			throw new IllegalArgumentException("ODSWriter#addLine argument must not be null");
 		}
 		if (size == 0) {
 			size = values.length; // when this is first line
 		}
 		if (size != values.length) {
 			throw new WriterException(String.format("Values size[%s] differs from the expected size[%s]",
 					values.length, size));
 		}
 
 		int column = 0;
 		OdfTableRow odfRow = table.getRowByIndex(currentLine + beginAtRow - 2);
 
 		for (String value : values) {
 			insertCellAtNum(odfRow, column++, value);
 
 		}
 		currentLine++;
 
 	}
 
 	/**
 	 * creates a new empty ODF table in the ODS document.
 	 * 
 	 * @param sheetName
 	 *            the table name.
 	 * @return the table
 	 */
 	private OdfTable createSheet(String sheetName) {
 		OdfTable table = OdfTable.newTable(outputDocument);
 		table.removeRowsByIndex(0, 5);
 		table.removeColumnsByIndex(0, 4);
 		table.setTableName(sheetName);
 		return table;
 	}
 
 	/**
 	 * Create a new ODS Document with a table.
 	 * 
 	 * @param sheetName
 	 *            the name of the table
 	 * @throws IOException
 	 *             if unable to create new ODS Document
 	 */
 	// TODO voir ecriture sur une feuille désignée par son index
 	private void createNewDocument(String sheetName) throws IOException {
 		try {
 			this.outputDocument = OdfSpreadsheetDocument.newSpreadsheetDocument();
 		} catch (Exception e) {
 			LOGGER.debug("Unable to create new ODS Document", e);
 			throw new IOException("Unable to create new ODS Document", e);
 		}
 		for (OdfTable feuille : this.outputDocument.getTableList()) { // TODO
 			// à
 			// revoir
 			if (!sheetName.equals(feuille.getTableName())) {
 				feuille.remove();
 			}
 		}
 		this.table = createSheet(sheetName);
 	}
 
 	/**
 	 * Opens the outFile as an ODS Document and opens the table or create the
 	 * table if not existe in the document.
 	 * 
 	 * @param sheetName
 	 *            the name of the table to open.
 	 * @throws IOException
 	 *             if unable to load the document.
 	 */
 	private void loadDocument(String sheetName) throws IOException {
 		try {
 			this.outputDocument = OdfSpreadsheetDocument.loadDocument(this.outFile);
 		} catch (Exception e) {
 			LOGGER.debug("Unable to load ODS Document", e);
 			throw new IOException("Unable to load ODS Document", e);
 		}
 
 		for (OdfTable feuille : this.outputDocument.getTableList()) { // TODO
 			// à
 			// revoir
 			if (sheetName.equals(feuille.getTableName())) {
 				this.table = feuille;
 				this.overridding = true;
 				break;
 			}
 		}
 		if (this.table == null) {
 			this.table = createSheet(sheetName);
 		}
 
 	}
 
 	/**
 	 * copy a cell in a row.
 	 * 
 	 * @param odfRow
 	 *            the row
 	 * @param cell
 	 *            the cell to insert
 	 */
 	private void insertCell(OdfTableRow odfRow, Cell cell) {
 		OdfTableCell odfCell = odfRow.getCellByIndex(cell.getNum() + beginAtColumn);
 
 		if (cell.isEmpty()) {
 			odfCell.setStringValue(null);
 		} else {
 			insertCell(odfCell, cell.getValue());
 		}
 	}
 
 	/**
 	 * Insert a cell in a row.
 	 * 
 	 * @param odfRow
 	 *            the row
 	 * @param num
 	 *            the column num after beginAtColumn
 	 * @param value
 	 *            the cell value
 	 */
 	private void insertCellAtNum(OdfTableRow odfRow, int num, String value) {
 		OdfTableCell odfCell = odfRow.getCellByIndex(num + beginAtColumn);
 
 		if (value == null) {
 			odfCell.setStringValue(null);
 		} else {
 			insertCell(odfCell, value);
 		}
 	}
 
 	/**
 	 * set a value on a cell. Because line breaks are not correctly interpreted,
 	 * insert a paragraph for each line identified by the cellParser.
 	 * 
 	 * @param odfCell
 	 *            the cell
 	 * @param value
 	 *            the value.
 	 */
 	private void insertCell(OdfTableCell odfCell, String value) {
 		odfCell.removeContent();
 		for (String line : cellParser.parse(value)) {
 			OdfTextParagraph paragraph;
 			try {
 				paragraph = new OdfTextParagraph(this.outputDocument.getContentDom()); // NOPMD
 																						// by
 																						// olivier
 																						// on
 																						// 01/02/12
 																						// 00:04
 				paragraph.setTextContent(line);
 				odfCell.getOdfElement().appendChild(paragraph);
 			} catch (Exception e) {
 				LOGGER.debug("Error on copy [" + value + "]", e);
 				throw new WriterException("Error on copy [" + value + "]", e);
 
 			}
 
 		}
 	}
 
 	/**
 	 * empties rows. Only if overriding and emptyingRow are true.
 	 * 
 	 * @param num
 	 *            the number of rows to empty. begins at currentLine after
 	 *            beginAtRow value.
 	 */
 	private void emptyRows(int num) {
 		if (overridding && emtpyingRow) {
 			for (int i = currentLine; i < num; i++) {
 				emptyCells(table.getRowByIndex(i + beginAtRow - 2), 0, size, true);
 			}
 		}
 	}
 
 	/**
 	 * empties cells of a row if overriding and emptyingRow are true.
 	 * 
 	 * @param row
 	 *            the row
 	 * @param begin
 	 *            first column (include) after beginAtColumn value.
 	 * @param end
 	 *            last column (exclude) after beginAtColumn value.
 	 * @param force
 	 *            if true bypass overriding and emptyingCell condition.
 	 */
 	private void emptyCells(OdfTableRow row, int begin, int end, boolean force) {
 		if (force || (overridding && emptyingCell)) {
 			for (int j = begin; j < end; j++) {
 				row.getCellByIndex(j + beginAtColumn).removeContent();
 			}
 		}
 	}
 
 	/**
 	 * 
 	 * This parser returns lines extracted from a string by interpreting \r, \n
 	 * or \r\n as line breaks found in it. Used to convert a string into an ODS
 	 * Cell content(where line breaks are not correctly interpreted) : For each
 	 * line returns by this parser, ODSWriter will create a paragraph into the
 	 * cell
 	 * 
 	 * @author Olivier Godineau
 	 * 
 	 */
 	public static class ODSParser extends AbstractParser<List<String>> {
 
 		@Override
 		public List<String> parse(String str) throws ParseException {
 
 			ArrayList<String> lines = new ArrayList<String>();
 			int beginAt = 0;
 
 			boolean skipLF = false;
 			boolean reindex = false;
 			char[] chars = str.toCharArray();
 			for (int i = 0; i < chars.length; i++) {
 				if (reindex) {
 					beginAt = i;
 					reindex = false;
 				}
 
 				if (chars[i] == '\r') {
 					lines.add(String.copyValueOf(chars, beginAt, i - beginAt));
 					if (chars[i] == '\r') {
 						skipLF = true;
 					}
 					reindex = true;
 				}
 
 				if (chars[i] == '\n') {
 					if (skipLF) {
 						skipLF = false;
 					} else {
 						lines.add(String.copyValueOf(chars, beginAt, i - beginAt));
 					}
 					reindex = true;
 				}
 			}
 
 			if (reindex) {
 				lines.add(String.copyValueOf(chars, beginAt, 0));
 			} else {
 				lines.add(String.copyValueOf(chars, beginAt, chars.length - beginAt));
 			}
 
 			return lines;
 
 		}
 	}
 
 }