/*
 * SSSync, a Simple and Stupid Synchronizer for data with multi-valued attributes
 * Copyright (C) 2014  Ludovic Pouzenc <ludovic@pouzenc.fr>
 *  
 * This file is part of SSSync.
 *
 *  SSSync is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  SSSync 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 General Public License
 *  along with SSSync.  If not, see <http://www.gnu.org/licenses/>
 */

package data.filters;

import java.util.Iterator;
import java.util.NoSuchElementException;

import data.MVDataEntry;
import data.io.AbstractMVDataReader;
import data.io.MVDataReader;

/**
 * Combines arbitrary number of MVData* sources while behaving same as AbstractMVDataReader.
 * This could enable a sync implementation to merge multiple sources
 *  before sync'ing in a transparent manner.
 * To prevent memory consumption, this assumes that all sources will be read
 *  with lexicographical ascending order on the "key" field.
 *  
 * @author lpouzenc
 */
public class MVDataCombiner extends AbstractMVDataReader {
	
	public enum MVDataCombineMode { PRIMARY_SOURCE, MERGE_APPEND, MERGE_REPLACE, OVERRIDE };
	
	private final MVDataReader[] readers;
	private final MVDataCombineMode[] mergeModes;
	
	private transient Iterator<MVDataEntry>[] readerIterators;
	private transient MVDataEntry[] lookAheadData;
	private transient String lastKey;
	
	
	public MVDataCombiner(String dataSourceName, MVDataReader[] readers, MVDataCombineMode mergeModes[]) {
		if ( readers == null || mergeModes == null || (mergeModes.length != readers.length) ) {
			throw new IllegalArgumentException("readers and mergeModes arrays should have same size");
		}
		if ( ! (mergeModes.length > 0) || mergeModes[0] != MVDataCombineMode.PRIMARY_SOURCE ) {
			throw new IllegalArgumentException("MVDataCombiner first mergeModes should always be PRIMARY_SOURCE");
		}
		
		this.dataSourceName = dataSourceName;
		this.readers = readers.clone();
		this.mergeModes = mergeModes.clone();
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	@SuppressWarnings("unchecked") /* for new Iterator[...] */
	public Iterator<MVDataEntry> iterator() {
		// Be cautious to reset everything
		readerIterators = new Iterator[readers.length];
		for (int i=0; i<readers.length;i++) {
			readerIterators[i] = readers[i].iterator();
		}
		lookAheadData = new MVDataEntry[readers.length];
		lastKey = null;
		
		return this;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public boolean hasNext() {
		for ( MVDataEntry line : lookAheadData ) {
			if ( line != null ) { return true; }
		}
		for ( MVDataReader reader : readers ) {
			if ( reader.hasNext() ) { return true; }
		}
		return false;
	}

	/**
	 * {@inheritDoc}
	 */
	@Override
	public MVDataEntry next() {

		final String currentKey = lookAheadAll();
	
		// Check if there was unsorted lines in source data
		if ( lastKey != null && (currentKey.compareTo(lastKey) < 0) ) {
				//XXX : this is checked here and in SafeDataReader (redundant), but both are optionnal...
				throw new UnsupportedOperationException("At least one data source is out of order. " +
						"Data sources are excepted to be read sorted by MVDataEntry key (ascending lexicogrpahical order)");
		}
		
		// Merge all data sources for key currentKey
		MVDataEntry result = null;
		for ( int i=0; i<lookAheadData.length; i++) {
			if ( lookAheadData[i] != null && lookAheadData[i].getKey().equals(currentKey) ) {
				if ( result == null ) {
					result = lookAheadData[i];
				} else {
					//XXX : some items in LDAP could have constrains like : "not multi-valued". Force MERGE_REPLACE mode ?
					//FIXME : honor all Combine modes
					result.mergeValues( (mergeModes[i] == MVDataCombineMode.MERGE_APPEND ),lookAheadData[i]);
				}
				lookAheadData[i]=null; // "Pop" the used entry
			}
		}
		
		lastKey = currentKey;
		
		return result;
	}

	private String lookAheadAll() {
		String minKey=null;
		
		// Feed the look-ahead buffer (look forward by 1 value for each reader)
		for ( int i=0; i<lookAheadData.length; i++) {
			if ( lookAheadData[i] == null && readerIterators[i].hasNext() ) {
				lookAheadData[i] = readerIterators[i].next();
			}
		}
		
		// Find the least RelData key from look-ahead buffers
		for (MVDataEntry entry: lookAheadData) {
			if ( entry != null ) {
				final String minKeyCandidate = entry.getKey();
				if ( minKey == null || minKey.compareTo(minKeyCandidate) > 0 ) {
					minKey = minKeyCandidate;
				}
			}
		}
		
		// Sanity checks
		if ( minKey == null ) {
			// Every reader is empty and look-ahead buffer is empty (hasNext() should have said false)
			throw new NoSuchElementException();
		}
		
		return minKey;
	}

	// Boring accessors
	
	public String getLastKey() {
		return lastKey;
	}
}