SynchroChangesVO

package fr.ifremer.quadrige2.synchro.vo;

/*-
 * #%L
 * Quadrige2 Core :: Quadrige2 Synchro Core
 * $Id:$
 * $HeadURL:$
 * %%
 * Copyright (C) 2017 Ifremer
 * %%
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * #L%
 */

import com.google.common.base.Joiner;
import com.google.common.base.Preconditions;
import com.google.common.base.Splitter;
import com.google.common.collect.*;
import fr.ifremer.common.synchro.meta.SynchroTableMetadata;
import fr.ifremer.common.synchro.service.RejectedRow;
import fr.ifremer.quadrige2.core.exception.Quadrige2TechnicalException;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;

import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Created by blavenie on 01/09/15.
 */
public class SynchroChangesVO {

	private final static char PK_VALUE_SEPARATOR = '|';

	private final static String INSERTS_SUFFIX = "inserts";
	private final static String UPDATES_SUFFIX = "updates";
	private final static String DELETES_SUFFIX = "deletes";
	private final static String REJECTS_SUFFIX = "rejects";

	private final static String READ_PROPERTY_REGEX = "^([^.]+)[.]([a-zA-Z]+)=(.+)$";

	private final Multimap<String, String> inserts = LinkedHashMultimap.create();
	private final Multimap<String, String> updates = LinkedHashMultimap.create();
	private final Multimap<String, String> deletes = LinkedHashMultimap.create();

	private Properties connectionProperties;

	/**
	 * Rejected rows.
	 * <p/>
	 * Will be written as a CSV string : [PK_AS_STR];[REJECT_STATUS];[UPDATE_DATE_NANOS_TIME]
	 * 25364~~~1;BAD_UPDATE_DATE;12437789901254
	 * <p/>
	 * see {@link fr.ifremer.common.synchro.service.SynchroResult#getRejectedRows()}
	 *
	 * @since 3.7
	 */
	protected final Multimap<String, String> rejectedRows = LinkedHashMultimap.create();

	/**
	 * All table treated.
	 *
	 * @since 1.0
	 */
	protected final Set<String> tableNames = Sets.newHashSet();

	/**
	 * <p>
	 * addTableName.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 */
	public void addTableName(String tableName) {
		tableNames.add(tableName);
	}

	/**
	 * <p>
	 * addReject.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @param rowInfo
	 *            a {@link java.lang.String} object.
	 */
	public void addReject(String tableName, String... rowInfo) {
		rejectedRows.put(tableName, Joiner.on(';').join(rowInfo));
	}

	/**
	 * <p>
	 * addReject.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @param rejectedRow
	 *            a {@link RejectedRow} object.
	 */
	public void addReject(String tableName, RejectedRow rejectedRow) {
		rejectedRows.put(tableName, rejectedRow.toString());
	}

	/**
	 * <p>
	 * addInsert.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @param pk
	 *            a {@link java.util.List} object.
	 */
	public void addInsert(final String tableName, List<Object> pk) {
		inserts.put(tableName, SynchroTableMetadata.toPkStr(pk));
	}

	/**
	 * <p>
	 * addUpdate.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @param pk
	 *            a {@link java.util.List} object.
	 */
	public void addUpdate(final String tableName, List<Object> pk) {
		updates.put(tableName, SynchroTableMetadata.toPkStr(pk));
	}

	/**
	 * <p>
	 * addDelete.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @param pk
	 *            a {@link java.util.List} object.
	 */
	public void addDelete(final String tableName, List<Object> pk) {
		deletes.put(tableName, SynchroTableMetadata.toPkStr(pk));
	}

	/**
	 * <p>
	 * Getter for the field <code>tableNames</code>.
	 * </p>
	 *
	 * @return a {@link java.util.Set} object.
	 */
	public Set<String> getTableNames() {
		return ImmutableSet.copyOf(tableNames);
	}

	/**
	 * <p>
	 * getTotalTreated.
	 * </p>
	 *
	 * @return a int.
	 */
	public int getTotalTreated() {
		return getTotalInserts() + getTotalUpdates() + getTotalDeletes() + getTotalRejects();
	}

	/**
	 * <p>
	 * getTotalInserts.
	 * </p>
	 *
	 * @return a int.
	 */
	public int getTotalInserts() {
		return inserts == null ? 0 : inserts.size();
	}

	/**
	 * <p>
	 * getTotalUpdates.
	 * </p>
	 *
	 * @return a int.
	 */
	public int getTotalUpdates() {
		return updates == null ? 0 : updates.size();
	}

	/**
	 * <p>
	 * getTotalDeletes.
	 * </p>
	 *
	 * @return a int.
	 */
	public int getTotalDeletes() {
		return deletes == null ? 0 : deletes.size();
	}

	/**
	 * <p>
	 * getTotalRejects.
	 * </p>
	 *
	 * @return a int.
	 */
	public int getTotalRejects() {
		return rejectedRows == null ? 0 : rejectedRows.size();
	}

	/**
	 * <p>
	 * getNbRows.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a int.
	 */
	public int getNbRows(String tableName) {
		return getNbInserts(tableName) + getNbUpdates(tableName) + getNbDeletes(tableName);
	}

	/**
	 * <p>
	 * getNbInserts.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a int.
	 */
	public int getNbInserts(String tableName) {
		return inserts.get(tableName).size();
	}

	/**
	 * <p>
	 * getNbUpdates.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a int.
	 */
	public int getNbUpdates(String tableName) {
		return updates.get(tableName).size();
	}

	/**
	 * <p>
	 * getNbDeletes.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a int.
	 */
	public int getNbDeletes(String tableName) {
		return deletes.get(tableName).size();
	}

	/**
	 * <p>
	 * Getter for the field <code>rejectedRows</code>.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a {@link java.lang.String} object.
	 */
	public String getRejectedRows(String tableName) {
		Collection<String> result = rejectedRows.get(tableName);
		if (CollectionUtils.isEmpty(result)) {
			return "";
		}
		StringBuilder sb = new StringBuilder();
		for(String row: result) {
			sb.append('\n').append(row);
		}
		return sb.substring(1/*remove first newline*/);
	}

	/**
	 * <p>
	 * addRejects.
	 * </p>
	 *
	 * @param rejectedRows
	 *            a {@link java.util.Map} object.
	 */
	public void addRejects(Map<String, String> rejectedRows) {
		Preconditions.checkNotNull(rejectedRows);

		for(String tableName: rejectedRows.keySet()) {
			String[] rows = rejectedRows.get(tableName).split("\n");
			for (String row: rows) {
				this.rejectedRows.put(tableName, row);
			}
		}
		tableNames.addAll(rejectedRows.keySet());
	}

	/**
	 * <p>
	 * Getter for the field <code>inserts</code>.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a {@link java.util.Collection} object.
	 */
	public Collection<String> getInserts(String tableName) {
		return inserts.get(tableName);
	}

	/**
	 * <p>
	 * Getter for the field <code>updates</code>.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a {@link java.util.Collection} object.
	 */
	public Collection<String> getUpdates(String tableName) {
		return updates.get(tableName);
	}

	/**
	 * <p>
	 * Getter for the field <code>deletes</code>.
	 * </p>
	 *
	 * @param tableName
	 *            a {@link java.lang.String} object.
	 * @return a {@link java.util.Collection} object.
	 */
	public Collection<String> getDeletes(String tableName) {
		return deletes.get(tableName);
	}

	/**
	 * <p>
	 * Getter for the field <code>connectionProperties</code>.
	 * </p>
	 *
	 * @return a {@link java.util.Properties} object.
	 */
	public Properties getConnectionProperties() {
		return connectionProperties;
	}

	/**
	 * <p>
	 * Setter for the field <code>connectionProperties</code>.
	 * </p>
	 *
	 * @param connectionProperties
	 *            a {@link java.util.Properties} object.
	 */
	public void setConnectionProperties(Properties connectionProperties) {
		this.connectionProperties = connectionProperties;
	}

	/**
	 * <p>
	 * writeToFile.
	 * </p>
	 *
	 * @param changeLogFile
	 *            a {@link java.io.File} object.
	 * @param append
	 *            a boolean.
	 */
	public void writeToFile(File changeLogFile, boolean append) {

		// Skip is empty
		if (isEmpty()) {
			return;
		}

		Writer writer = null;
		try {

			// Create the writer for file (append)
			writer = new BufferedWriter(new FileWriter(changeLogFile, append && changeLogFile.exists()));

			// Inserts
			if (!inserts.isEmpty()) {
				writeToFile(writer, inserts, INSERTS_SUFFIX);
			}

			// Updates
			if (!updates.isEmpty()) {
				writeToFile(writer, updates, UPDATES_SUFFIX);
			}

			// Deletes
			if (!deletes.isEmpty()) {
				writeToFile(writer, deletes, DELETES_SUFFIX);
			}

			// Rejects
			if (!rejectedRows.isEmpty()) {
				writeToFile(writer, rejectedRows, REJECTS_SUFFIX);
			}
		} catch (Exception e) {
			throw new Quadrige2TechnicalException("Unable to write synchronization diff into file: " + changeLogFile.getPath(), e);
		} finally {
			IOUtils.closeQuietly(writer);
		}
	}

	/**
	 * <p>
	 * readFromFile.
	 * </p>
	 *
	 * @param changeLogFile
	 *            a {@link java.io.File} object.
	 */
	public void readFromFile(File changeLogFile) {
		readFromFile(changeLogFile, true);
	}

	/**
	 * <p>
	 * addFromFile.
	 * </p>
	 *
	 * @param changeLogFile
	 *            a {@link java.io.File} object.
	 */
	public void addFromFile(File changeLogFile) {
		readFromFile(changeLogFile, false);
	}

	/**
	 * <p>
	 * isEmpty.
	 * </p>
	 *
	 * @return a boolean.
	 */
	public boolean isEmpty() {
		return inserts.isEmpty() && updates.isEmpty() && deletes.isEmpty() && rejectedRows.isEmpty();
	}

	/**
	 * Clear every fields
	 */
	public void clear() {
		inserts.clear();
		updates.clear();
		deletes.clear();
		rejectedRows.clear();
		tableNames.clear();
	}

	/* -- Internal methods -- */

	/**
	 * <p>
	 * readFromFile.
	 * </p>
	 *
	 * @param changeLogFile
	 *            a {@link java.io.File} object.
	 * @param clearBeforeRead
	 *            a boolean.
	 */
	protected void readFromFile(File changeLogFile, boolean clearBeforeRead) {

		// Clear existing data
		if (clearBeforeRead) {
			clear();
		}

		BufferedReader reader = null;
		try {

			// Create the writer for file (append)
			reader = new BufferedReader(new FileReader(changeLogFile));

			Pattern propertyPattern = Pattern.compile(READ_PROPERTY_REGEX);
			Splitter propertyValueSplitter = Splitter.on(PK_VALUE_SEPARATOR).omitEmptyStrings().trimResults();

			String line = reader.readLine();
			while (line != null) {

				// Skip empty lines
				if (StringUtils.isNotBlank(line)) {
					Matcher propertyMatcher = propertyPattern.matcher(line.trim());
					if (propertyMatcher.matches()) {
						String tableName = propertyMatcher.group(1);
						String propertySuffix = propertyMatcher.group(2);
						String propertyValue = propertyMatcher.group(3);

						if (StringUtils.isNotBlank(propertyValue)) {
							tableNames.add(tableName);

							if (INSERTS_SUFFIX.equals(propertySuffix)) {
								inserts.putAll(tableName, propertyValueSplitter.split(propertyValue));
							}
							else if (UPDATES_SUFFIX.equals(propertySuffix)) {
								updates.putAll(tableName, propertyValueSplitter.split(propertyValue));
							}
							else if (DELETES_SUFFIX.equals(propertySuffix)) {
								deletes.putAll(tableName, propertyValueSplitter.split(propertyValue));
							}
							else if (REJECTS_SUFFIX.equals(propertySuffix)) {
								rejectedRows.putAll(tableName, propertyValueSplitter.split(propertyValue));
							}
						}

					}
				}

				// Iterate to next line
				line = reader.readLine();

			} // while
		} catch (Exception e) {
			throw new Quadrige2TechnicalException("Unable to write synchronization change log into file: " + changeLogFile.getPath(), e);
		} finally {
			IOUtils.closeQuietly(reader);
		}
	}

	/**
	 * <p>
	 * writeToFile.
	 * </p>
	 *
	 * @param writer
	 *            a {@link java.io.Writer} object.
	 * @param pksByTableName
	 *            a {@link com.google.common.collect.Multimap} object.
	 * @param propertySuffix
	 *            a {@link java.lang.String} object.
	 * @throws java.io.IOException
	 *             if any.
	 */
	protected void writeToFile(Writer writer, Multimap<String, String> pksByTableName, String propertySuffix) throws IOException {

		StringBuilder sb = new StringBuilder();
		for (String tableName : pksByTableName.keySet()) {

			// Reset the string builder
			sb.setLength(0);
			for (String pkStr : pksByTableName.get(tableName)) {
				sb.append(PK_VALUE_SEPARATOR).append(pkStr);
			}

			writer.write(String.format("%s.%s=%s\n",
					tableName,
					propertySuffix,
					sb.substring(1)
			));
		}
	}

}