RowBean

/*
 * Copyright 2013 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.bean;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import olg.csv.base.IReader;
import olg.csv.base.IWriter;
import olg.csv.base.csv.CSVReader;
import olg.csv.base.csv.CSVSettings;
import olg.csv.base.csv.CSVWriter;
import olg.csv.base.ods.ODSReader;
import olg.csv.base.ods.ODSSettings;
import olg.csv.base.ods.ODSWriter;
import olg.csv.bean.annotations.processor.AnnotationProcessorException;
import olg.csv.bean.annotations.processor.RowBeanProcessor;
import olg.csv.bean.parser.ParseException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Main class to manage bean writing/reading based on Annotations setted on bean class.
 *
 * @author Olivier Godineau
 *
 * @param <T>
 *            the bean to manage.
 */
public final class RowBean<T> {
	/**
	 * class logger.
	 */
	private static final Logger LOGGER = LoggerFactory.getLogger(RowBean.class);
	/**
	 * The class this RowBean instance deals with.
	 */
	private Class<T> clazz;

	/**
	 * the processor to load RowProcessor/BeanProcessor/file reader settings/file writer settings.
	 */
	private RowBeanProcessor<T> rowBeanProcessor;

	/**
	 * Constructor.
	 *
	 * @param clazz
	 *            the class RowBean instance supports and deals with.
	 */
	public RowBean(Class<T> clazz) {
		super();
		if (clazz == null) {
			throw new IllegalArgumentException("RowBean constructor class argument must not be null");
		}
		this.clazz = clazz;
		this.rowBeanProcessor = new RowBeanProcessor<T>(this.clazz);
	}

	/**
	 * Returns a ODS or CSV reader with settings read from RowBean Annotation setted on T class. throws
	 * IllegalArgumentException if file is null or or it's not possible to define a reader.
	 *
	 * @param in
	 *            the file. Must be an ODS or CSV file. ODS files must have .ods or.ODS extension. CSV files must have
	 *            .csv,.CSV,.txt, .TXT, .dat or.DAT.
	 * @return the reader corresponding to the extension of the file.
	 * @throws IOException
	 *             if an error occurs during the file opening.
	 * @throws AnnotationProcessorException
	 *             an error occurs on settings annotation reading at the rowBean annotation setted on the T class.
	 *
	 */
	public IReader getReader(File in) throws IOException, AnnotationProcessorException {
		if (in == null) {
			throw new IllegalArgumentException("RowBean.getReader file argument must not be null");
		}

		if (!in.exists()) {
			throw new IllegalArgumentException(String.format("RowBean.getReader file argument [%s] doesn't exist",
					in.getAbsolutePath()));
		}
		// Cas CSV
		if (isCSVFile(in)) {
			return new CSVReader(in, this.rowBeanProcessor.getReadingCSVSettings());
		}
		// Cas ODS
		if (isODSFile(in)) {
			return new ODSReader(in, this.rowBeanProcessor.getReadingODSSettings());
		}
		throw new IllegalArgumentException(
				"RowBean.getReader has not identified the file in argument as an ODS or CSV file."
						+ " Use instead the constructor of the class of your choice : ODSReader or CSVReader.");

	}

	/**
	 * Returns a ODS or CSV writer with settings read from RowBean Annotation setted on T class. Throws
	 * IllegalArgumentException if file is null or or it's not possible to define a writer.
	 *
	 * @param out
	 *            the file. Must be an ODS or CSV file. ODS files must have .ods or.ODS extension. CSV files must have
	 *            .csv,.CSV,.txt, .TXT, .dat or.DAT.
	 * @return the writer the row writer corresponding to the extension of the file.
	 * @throws AnnotationProcessorException
	 *             error occurs on writing settings RowBean annotation
	 * @throws IOException
	 *             errors occurs on file opening
	 */
	public IWriter getWriter(File out) throws AnnotationProcessorException, IOException {
		if (out == null) {
			throw new IllegalArgumentException("RowBean.getWriter file argument must not be null");
		}
		if (isCSVFile(out)) {
			return new CSVWriter(out, this.rowBeanProcessor.getWritingCSVSettings());
		}
		if (isODSFile(out)) {
			return new ODSWriter(out, this.rowBeanProcessor.getWritingODSSettings());
		}
		throw new IllegalArgumentException(
				"RowBean.getWriter has not identified the file in argument as an ODS or CSV file."
						+ "  Use instead the constructor of the class ODSWriter or CSVWriter");

	}
	/**
	 * Extracts a list from a CSV file opened with some CSV settings. Use Annotations on T class to define how to read
	 * bean and how set the file reader.
	 *
	 * @param in
	 *            the CSV file.
	 * @param csvSettings
	 *            the settings the file will be opened with.
	 * @return the list of T extracted from the file.
	 * @throws AnnotationProcessorException
	 *             if an error occurs during the annotation reading on T class.
	 * @throws IOException
	 *             if an error occurs during the file opening.
	 */
	public List<T> fromFile(File in, CSVSettings csvSettings) throws AnnotationProcessorException, IOException {
		return fromReader(new CSVReader(in, csvSettings), in);
	}

	/**
	 * Extracts a list from an ODS file opened with some ODS settings. Use Annotations on T class to define how to read
	 * beans and how to set the file reader.
	 *
	 * @param in
	 *            the ODS file.
	 * @param odsSettings
	 *            the settings the file will be opened with.
	 * @return the list of T extracted from the file.
	 * @throws AnnotationProcessorException
	 *             if error occurs during the annotation reading on T class.
	 * @throws IOException
	 *             if an error occurs during the file opening.
	 */
	public List<T> fromFile(File in, ODSSettings odsSettings) throws AnnotationProcessorException, IOException {
		return fromReader(new ODSReader(in, odsSettings), in);
	}
	/**
	 * Extracts a list from a file. Use Annotations on T class to define how to read bean and how set the file reader.
	 * Throws IllegalArgumentException if file is null or or it's not possible to define a reader.
	 *
	 * @param in
	 *            the file. Must be an ODS or CSV file. ODS files must have .ods or.ODS extension. CSV files must have
	 *            .csv,.CSV,.txt, .TXT, .dat or.DAT. Use the reading settings read from RowBean Annotation setted on T
	 *            class.
	 * @return the list of T extracted from the file.
	 * @throws AnnotationProcessorException
	 *             if error occurs during the annotation reading on T class.
	 * @throws IOException
	 *             if an error occurs during the file opening.
	 */
	public List<T> fromFile(File in) throws AnnotationProcessorException, IOException {

		return fromReader(getReader(in), in);
	}

	/**
	 * Copy in a new file a list of T. Use the RowBean annotation setted on T class. Throws IllegalArgumentException if
	 * file is null or or it's not possible to define a writer.
	 *
	 * @param beans
	 *            the list.
	 * @param out
	 *            the file. Must be an ODS or CSV file. ODS files must have .ods or.ODS extension. CSV files must have
	 *            .csv,.CSV,.txt, .TXT, .dat or.DAT. Use writing settings read from RowBean Annotation setted on T
	 *            class.
	 * @throws AnnotationProcessorException
	 *             if error occurs during the annotation reading on T class.
	 * @throws IOException
	 *             if the file exists but is a directory rather than a regular file, does not exist but cannot be
	 *             created, or cannot be opened for any other reason
	 */
	public void toFile(List<T> beans, File out) throws AnnotationProcessorException, IOException {

		toWriter(beans, getWriter(out), out);
	}

	/**
	 * Copy in a CSV file a list of T. Use the RowBean annotation setted on T class.
	 *
	 * @param beans
	 *            the beans to copy.
	 * @param out
	 *            the file.
	 * @param csvSettings
	 *            the settings the file is written with.
	 * @throws AnnotationProcessorException
	 *             if error occurs during the annotation reading on T class.
	 * @throws IOException
	 *             if the file exists but is a directory rather than a regular file, does not exist but cannot be
	 *             created, or cannot be opened for any other reason
	 */
	public void toFile(List<T> beans, File out, CSVSettings csvSettings) throws AnnotationProcessorException,
			IOException {
		toWriter(beans, new CSVWriter(out, csvSettings), out);
	}

	/**
	 * Copy in an ODS file a list of T. Use the RowBean annotation setted on T class.
	 *
	 * @param beans
	 *            the T beans to copy.
	 * @param out
	 *            the file
	 * @param odsSettings
	 *            the settings the file is written with.
	 * @throws AnnotationProcessorException
	 *             if error occurs during the annotation reading on T class.
	 * @throws IOException
	 *             if the file exists but is a directory rather than a regular file, does not exist but cannot be
	 *             created, or cannot be opened for any other reason
	 */
	public void toFile(List<T> beans, File out, ODSSettings odsSettings) throws AnnotationProcessorException,
			IOException {
		toWriter(beans, new ODSWriter(out, odsSettings), out);
	}

	/**
	 * check if a file extension matchs text file extension(.csv,.txt,.dat).
	 *
	 * @param file
	 *            the file to check
	 * @return true if the file has a text file extension.
	 */
	private static boolean isCSVFile(File file) {
		return file.getName().matches(".+\\.(:?csv|CSV|TXT|txt|dat|DAT)$");

	}
	/**
	 * check if a file extension matchs ODS file extension.
	 *
	 * @param file
	 *            the file to check
	 * @return true if has ODS extension
	 */
	private static boolean isODSFile(File file) {
		return file.getName().matches(".+\\.(:?ods|ODS)$");

	}
	/**
	 * Provides the row processor built from the annoted T class.
	 *
	 * @return the row processor.
	 * @throws AnnotationProcessorException
	 *             if an error occurs during processor building.
	 */
	private IRowProcessor<T> getRowProcessor() throws AnnotationProcessorException {
		return this.rowBeanProcessor.getRowProcessor();
	}

	/**
	 * Provides the Bean processor built from the annoted T class.
	 *
	 * @return the bean processor.
	 * @throws AnnotationProcessorException
	 *             if error occurs during annotation processing.
	 */
	private IBeanProcessor<T> getBeanProcessor() throws AnnotationProcessorException {
		return this.rowBeanProcessor.getBeanProcessor();
	}

	/**
	 * Extracts a list from a reader.
	 *
	 * @param fileReader
	 *            the reader
	 * @param in
	 *            the file
	 * @return the list of T extracted from the file.
	 * @throws AnnotationProcessorException
	 *             if error occurs during the annotation reading on T class.
	 */
	private List<T> fromReader(IReader fileReader, File in) throws AnnotationProcessorException {
		List<T> list = new ArrayList<T>();
		BeanReader<T> reader = null;
		int count = 0;
		try {
			reader = new BeanReader<T>(getBeanProcessor(), fileReader);
			while (reader.hasNext()) {
				try {
					count++;
					list.add(reader.next());
				} catch (ParseException ex) {
					LOGGER.warn(String.format("Error at record[%s] on Reading file[%s] ", count, in.getAbsolutePath()),
							ex);
				}
			}
		} finally {
			if (reader != null) {
				reader.close();
			}
		}
		return list;
	}

	/**
	 * Copy a list of T on a writer.
	 *
	 * @param beans
	 *            the beans to copy.
	 * @param fileWriter
	 *            the writer
	 * @param out
	 *            the opened file.
	 * @throws AnnotationProcessorException
	 *             if error occurs during the annotation reading on T class.
	 */
	private void toWriter(List<T> beans, IWriter fileWriter, File out) throws AnnotationProcessorException {

		if (beans == null) {
			throw new IllegalArgumentException();
		}

		BeanWriter<T> writer = null;
		try {
			writer = new BeanWriter<T>(getRowProcessor(), fileWriter);

			for (T bean : beans) {
				try {
					writer.write(bean);
				} catch (PropertyException ex) {
					LOGGER.warn(String.format("Error on writing bean[%s] in file[%s] ", bean, out.getAbsolutePath()),
							ex);
				}
			}
		} finally {
			if (writer != null) {
				writer.close();
			}
		}
	}

}