package fr.ifremer.quadrige3.synchro.vo;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 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.Splitter;
  import com.google.common.collect.ImmutableSet;
  import com.google.common.collect.LinkedHashMultimap;
  import com.google.common.collect.Multimap;
  import com.google.common.collect.Sets;
  import fr.ifremer.common.synchro.meta.SynchroTableMetadata;
  import fr.ifremer.common.synchro.service.RejectedRow;
  import fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.exception.QuadrigeTechnicalException;
  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
  	 */
  	private final Multimap<String, String> rejectedRows = LinkedHashMultimap.create();
  
  	/**
  	 * All table treated.
  	 *
  	 * @since 1.0
  	 */
  	private 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.size();
 	}
 
 	/**
 	 * <p>
 	 * getTotalUpdates.
 	 * </p>
 	 *
 	 * @return a int.
 	 */
 	public int getTotalUpdates() {
 		return updates.size();
 	}
 
 	/**
 	 * <p>
 	 * getTotalDeletes.
 	 * </p>
 	 *
 	 * @return a int.
 	 */
 	public int getTotalDeletes() {
 		return deletes.size();
 	}
 
 	/**
 	 * <p>
 	 * getTotalRejects.
 	 * </p>
 	 *
 	 * @return a int.
 	 */
 	public int getTotalRejects() {
 		return 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) {
 		Assert.notNull(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 QuadrigeTechnicalException("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 QuadrigeTechnicalException("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)
 			));
 		}
 	}
 
 }