# OneToManyWithIndexedMappedAssociationEngine.java

    package org.codefilarete.stalactite.engine.runtime.onetomany;

    import java.util.Collection;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.IdentityHashMap;
    import java.util.LinkedHashSet;
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.function.Function;
    import java.util.stream.Collectors;
    import java.util.stream.Stream;
    import javax.annotation.Nullable;

    import org.codefilarete.reflection.Accessor;
    import org.codefilarete.reflection.Mutator;
    import org.codefilarete.stalactite.engine.diff.AbstractDiff;
    import org.codefilarete.stalactite.engine.diff.IndexedDiff;
    import org.codefilarete.stalactite.engine.listener.SelectListener;
    import org.codefilarete.stalactite.engine.runtime.CollectionUpdater;
    import org.codefilarete.stalactite.engine.runtime.ConfiguredRelationalPersister;
    import org.codefilarete.stalactite.engine.runtime.load.AbstractJoinNode;
    import org.codefilarete.stalactite.engine.runtime.load.EntityJoinTree;
    import org.codefilarete.stalactite.engine.runtime.onetomany.IndexedMappedManyRelationDescriptor.InMemoryRelationHolder;
    import org.codefilarete.stalactite.mapping.Mapping.ShadowColumnValueProvider;
    import org.codefilarete.stalactite.query.api.Fromable;
    import org.codefilarete.stalactite.sql.ddl.structure.Column;
    import org.codefilarete.stalactite.sql.ddl.structure.Table;
    import org.codefilarete.tool.Duo;
    import org.codefilarete.tool.Reflections;
    import org.codefilarete.tool.ThreadLocals;
    import org.codefilarete.tool.collection.Arrays;
    import org.codefilarete.tool.collection.Iterables;
    import org.codefilarete.tool.trace.MutableInt;

    import static org.codefilarete.tool.Nullable.nullable;

    /**
     * @author Guillaume Mary
     */
    public class OneToManyWithIndexedMappedAssociationEngine<SRC, TRGT, SRCID, TRGTID, S extends Collection<TRGT>, LEFTTABLE extends Table<LEFTTABLE>, RIGHTTABLE extends Table<RIGHTTABLE>>
    		extends OneToManyWithMappedAssociationEngine<SRC, TRGT, SRCID, TRGTID, S, LEFTTABLE, RIGHTTABLE> {

    	public OneToManyWithIndexedMappedAssociationEngine(ConfiguredRelationalPersister<TRGT, TRGTID> targetPersister,
    													   IndexedMappedManyRelationDescriptor<SRC, TRGT, S, SRCID, TRGTID, RIGHTTABLE> manyRelationDefinition,
    													   ConfiguredRelationalPersister<SRC, SRCID> sourcePersister,
    													   Set<Column<RIGHTTABLE, ?>> mappedReverseColumns,
    													   Function<SRCID, Map<Column<RIGHTTABLE, ?>, ?>> reverseColumnsValueProvider) {
    		super(targetPersister, manyRelationDefinition, sourcePersister, mappedReverseColumns, reverseColumnsValueProvider);
    	}

    	@Override
    	public IndexedMappedManyRelationDescriptor<SRC, TRGT, S, SRCID, TRGTID, RIGHTTABLE> getManyRelationDescriptor() {
    		return (IndexedMappedManyRelationDescriptor<SRC, TRGT, S, SRCID, TRGTID, RIGHTTABLE>) manyRelationDescriptor;
    	}

    	@Override
    	public String addSelectCascade(boolean loadSeparately) {
    		// we add target subgraph joins to main persister
    		Set<Column<RIGHTTABLE, ?>> columnsToSelect = new HashSet<>(targetPersister.<RIGHTTABLE>getMainTable().getPrimaryKey().getColumns());
    		columnsToSelect.add(getManyRelationDescriptor().getIndexingColumn());
    		String relationJoinNodeName = targetPersister.joinAsMany(
    				EntityJoinTree.ROOT_JOIN_NAME,
    				sourcePersister,
    				manyRelationDescriptor.getCollectionAccessPoint(),
    				sourcePersister.<LEFTTABLE>getMainTable().getPrimaryKey(),
    				getManyRelationDescriptor().getReverseColumn(),
    				manyRelationDescriptor.getRelationFixer(),
    				(columnedRow) -> {
    					TRGTID identifier = targetPersister.getMapping().getIdMapping().getIdentifierAssembler().assemble(columnedRow);
    					Integer targetEntityIndex = columnedRow.get(getManyRelationDescriptor().getIndexingColumn());
    					return identifier + "-" + targetEntityIndex;
    				},
    				columnsToSelect,
    				true,
    				loadSeparately);

    		addIndexSelection(relationJoinNodeName);

    		// we must trigger subgraph event on loading of our own graph, this is mainly for event that initializes things because given ids
    		// are not those of their entity
    		SelectListener<TRGT, TRGTID> targetSelectListener = targetPersister.getPersisterListener().getSelectListener();
    		sourcePersister.addSelectListener(new SelectListener<SRC, SRCID>() {
    			@Override
    			public void beforeSelect(Iterable<SRCID> ids) {
    				// since ids are not those of its entities, we should not pass them as argument, this will only initialize things if needed
    				targetSelectListener.beforeSelect(Collections.emptyList());
    			}

    			@Override
    			public void afterSelect(Set<? extends SRC> result) {
    				Set<TRGT> collect = Iterables.stream(result).flatMap(src -> nullable(manyRelationDescriptor.getCollectionAccessPoint().get(src))
    						.map(Collection::stream)
    						.getOr(Stream.empty()))
    						.collect(Collectors.toSet());
    				targetSelectListener.afterSelect(collect);
    			}

    			@Override
    			public void onSelectError(Iterable<SRCID> ids, RuntimeException exception) {
    				// since ids are not those of its entities, we should not pass them as argument
    				targetSelectListener.onSelectError(Collections.emptyList(), exception);
    			}
    		});

    		return relationJoinNodeName;
    	}

    	private void addIndexSelection(String joinNodeName) {
    		// Implementation note: 2 possibilities
    		// - keep object indexes and put sorted beans in a temporary List, then add them all to the target List
    		// - keep object indexes and sort the target List through a comparator of indexes
    		// The latter is used because target List is already filled by the relationFixer
    		// If we use the former we must change the relation fixer and keep a temporary List. Seems a bit more complex.
    		// May be changed if any performance issue is noticed
    		sourcePersister.addSelectListener(new SelectListener<SRC, SRCID>() {
    			@Override
    			public void beforeSelect(Iterable<SRCID> ids) {
    				InMemoryRelationHolder relationFixer = (InMemoryRelationHolder) manyRelationDescriptor.getRelationFixer();
    				relationFixer.init();
    			}

    			@Override
    			public void afterSelect(Set<? extends SRC> result) {
    				InMemoryRelationHolder relationFixer = (InMemoryRelationHolder) manyRelationDescriptor.getRelationFixer();
    				relationFixer.applySort(result);
    				cleanContext();
    			}

    			@Override
    			public void onSelectError(Iterable<SRCID> ids, RuntimeException exception) {
    				cleanContext();
    			}

    			private void cleanContext() {
    				InMemoryRelationHolder relationFixer = (InMemoryRelationHolder) manyRelationDescriptor.getRelationFixer();
    				relationFixer.clear();
    			}
    		});
    		AbstractJoinNode<TRGT, Fromable, Fromable, TRGTID> join = (AbstractJoinNode<TRGT, Fromable, Fromable, TRGTID>) sourcePersister.getEntityJoinTree().getJoin(joinNodeName);
    		join.setConsumptionListener((trgt, columnValueProvider) -> {
    			InMemoryRelationHolder relationFixer = (InMemoryRelationHolder) manyRelationDescriptor.getRelationFixer();
    			Map<TRGTID, Integer> indexPerTargetId = relationFixer.getCurrentSelectedIndexes();
    			// indexPerTargetId may not be present because its mechanism was added on persisterListener which is the one of the source bean
    			// so in case of entity loading from its own persister (targetPersister) ThreadLocal is not available
    			if (indexPerTargetId != null) {
    				// Indexing column is not defined in targetPersister.getMapping().getRowTransformer() but is present in row
    				// because it was read from ResultSet
    				int index = columnValueProvider.get(getManyRelationDescriptor().getIndexingColumn());
    				TRGTID relationOwnerId = targetPersister.getMapping().getIdMapping().getIdentifierAssembler().assemble(columnValueProvider);
    				indexPerTargetId.put(relationOwnerId, index);
    			}
    		});
    	}

    	@Override
    	public void addInsertCascade(ConfiguredRelationalPersister<TRGT, TRGTID> targetPersister) {
    		// For a List and a given manner to get its owner (so we can deduce index value), we configure persistence to keep index value in database
    		addIndexInsertion();
    		super.addInsertCascade(targetPersister);
    	}

    	/**
    	 * Adds a "listener" that will amend insertion of the index column filled with its value
    	 */
    	private <TARGETTABLE extends Table<TARGETTABLE>> void addIndexInsertion() {
    		// we declare the indexing column as a silent one, then AfterInsertCollectionCascader will insert it
    		Accessor<SRC, S> collectionGetter = this.manyRelationDescriptor.getCollectionAccessPoint();
    		ShadowColumnValueProvider<TRGT, TARGETTABLE> indexValueProvider = new ShadowColumnValueProvider<TRGT, TARGETTABLE>() {
    			@Override
    			public boolean accept(TRGT entity) {
    				// NB: source entity must be taken on relation storage context, not through manyRelationDefinition.getReverseGetter()
    				// because it doesn't cover all cases, moreover relation storage context is maintained for foreign key
    				// management which is make more sense that index strategy rely on it too
    				SRC sourceEntity = giveRelationStorageContext().get(entity);
    				return
    						// Source entity can be null if target was removed from the collection, then an SQL update is required to set its reference
    						// column to null as well as its indexing column
    						sourceEntity == null
    								// Case of polymorphic inheritance with an abstract one-to-many relation redefined on each subclass (think to
    								// AbstractQuestion and mapOneToMany(AbstractQuestion::getChoices, ..) declared for single and multiple choice question):
    								// we get several source persister which are quite the same at a slighlty difference on collection getter : due to JVM
    								// serialization of method reference, it keeps original generic type somewhere in the serialized form of method reference
    								// (SerializedLambda.instantiatedMethodType), then applying this concrete class (when looking for target entity index in
    								// collection) and not the abstract one, which produces a ClassCastException. As a consequence we must check that
    								// collection getter matches given entity (which is done through source persister, because there's no mean to do it
    								// with collection getter).
    								|| sourcePersister.getMapping().getClassToPersist().isInstance(sourceEntity);
    			}

    			@Override
    			public Set<Column<TARGETTABLE, ?>> getColumns() {
    				return Collections.singleton((Column) getManyRelationDescriptor().getIndexingColumn());
    			}

    			@Override
    			public Map<Column<TARGETTABLE, ?>, ?> giveValue(TRGT target) {
    				SRC source = giveRelationStorageContext().get(target);
    				Integer targetEntityIndex;
    				if (source == null) {
    					// index can be null if target entity has been removed from source, no exception to be thrown here
    					// since it's a normal case
    					targetEntityIndex = null;
    				} else {
    					targetEntityIndex = computeTargetIndex(source, target);
    				}
    				Map<Column<TARGETTABLE, ?>, Object> result = new HashMap<>();
    				result.put((Column) getManyRelationDescriptor().getIndexingColumn(), targetEntityIndex);
    				return result;
    			}

    			/**
    			 * Finds the index of target instance in the one-to-many collection of source entity.
    			 * Supports {@link List} and {@link LinkedHashSet} collection type. Else an exception is thrown.
    			 *
    			 * @param source an entity that owns the one-to-many relation
    			 * @param target an entity expected to be in one-to-many relation
    			 * @return the index of target instance in one-to-many relation
    			 */
    			private int computeTargetIndex(SRC source, TRGT target) {
    				int result;
    				S apply = collectionGetter.get(source);
    				if (apply instanceof List) {
    					result = ((List<?>) apply).indexOf(target) + INDEXED_COLLECTION_FIRST_INDEX_VALUE;
    				} else if (apply instanceof LinkedHashSet) {
    					MutableInt counter = new MutableInt(INDEXED_COLLECTION_FIRST_INDEX_VALUE - 1);
    					for (Object o : apply) {
    						counter.increment();
    						if (o == target) {
    							break;
    						}
    					}
    					result = counter.getValue();
    				} else {
    					throw new UnsupportedOperationException("Index computation is not supported for " + Reflections.toString(apply.getClass()));
    				}
    				return result;
    			}
    		};

    		targetPersister.<TARGETTABLE>getMapping().addShadowColumnInsert(indexValueProvider);
    		targetPersister.<TARGETTABLE>getMapping().addShadowColumnUpdate(indexValueProvider);
    	}

    	@Override
    	protected void addTargetInstancesUpdateCascader(boolean shouldDeleteRemoved) {
    		Mutator<Duo<SRC, SRC>, Boolean> collectionUpdater = new ListCollectionUpdater<>(
    				this.manyRelationDescriptor.getCollectionAccessPoint(),
    				this.targetPersister,
    				this.manyRelationDescriptor.getReverseSetter(),
    				shouldDeleteRemoved,
    				this.targetPersister.getMapping()::getId,
    				getManyRelationDescriptor().getIndexingColumn());
    		sourcePersister.getPersisterListener().addUpdateListener(new AfterUpdateTrigger<>(collectionUpdater));
    	}

    	private static class ListCollectionUpdater<SRC, TRGT, ID, C extends Collection<TRGT>, TARGETTABLE extends Table<TARGETTABLE>> extends CollectionUpdater<SRC, TRGT, C> {

    		/**
    		 * Context for indexed mapped List. Will keep bean index during insert between "unrelated" methods/phases :
    		 * indexes must be computed then applied into SQL order, but this particular feature crosses over layers (entities
    		 * and SQL) which is not implemented. In such circumstances, ThreadLocal comes to the rescue.
    		 * Could be static, but would lack the TRGT typing, which leads to some generics errors, so left non static (acceptable small overhead)
    		 */
    		@SuppressWarnings("java:S5164" /* remove() is called by ThreadLocals.AutoRemoveThreadLocal */)
    		private final ThreadLocal<Map<TRGT, Integer>> currentUpdatableListIndex = new ThreadLocal<>();

    		/**
    		 * Context for indexed mapped List. Will keep bean index during update between "unrelated" methods/phases :
    		 * indexes must be computed then applied into SQL order, but this particular feature crosses over layers (entities
    		 * and SQL) which is not implemented. In such circumstances, ThreadLocal comes to the rescue.
    		 * Could be static, but would lack the TRGT typing, which leads to some generics errors, so left non static (acceptable small overhead)
    		 */
    		@SuppressWarnings("java:S5164" /* remove() is called by ThreadLocals.AutoRemoveThreadLocal */)
    		private final ThreadLocal<Map<TRGT, Integer>> currentInsertableListIndex = new ThreadLocal<>();
    		private final Column<TARGETTABLE, Integer> indexingColumn;

    		private ListCollectionUpdater(Accessor<SRC, C> collectionGetter,
    									  ConfiguredRelationalPersister<TRGT, ID> targetPersister,
    									  @Nullable Mutator<TRGT, SRC> reverseSetter,
    									  boolean shouldDeleteRemoved,
    									  Accessor<TRGT, ?> idProvider,
    									  Column<TARGETTABLE, Integer> indexingColumn) {
    			super(collectionGetter, targetPersister, reverseSetter, shouldDeleteRemoved, idProvider);
    			this.indexingColumn = indexingColumn;
    			addShadowIndexInsert(targetPersister);
    			addShadowIndexUpdate(targetPersister);

    		}

    		private void addShadowIndexUpdate(ConfiguredRelationalPersister<TRGT, ID> targetPersister) {
    			targetPersister.<TARGETTABLE>getMapping().addShadowColumnInsert(new ShadowColumnValueProvider<TRGT, TARGETTABLE>() {

    				@Override
    				public boolean accept(TRGT entity) {
    					return currentUpdatableListIndex.get() != null && currentUpdatableListIndex.get().containsKey(entity);
    				}

    				@Override
    				public Set<Column<TARGETTABLE, ?>> getColumns() {
    					return Arrays.asHashSet(indexingColumn);
    				}

    				@Override
    				public Map<Column<TARGETTABLE, ?>, ?> giveValue(TRGT bean) {
    					Map<Column<TARGETTABLE, ?>, Object> result = new HashMap<>();
    					result.put(indexingColumn, currentUpdatableListIndex.get().get(bean));
    					return result;
    				}
    			});
    		}

    		private void addShadowIndexInsert(ConfiguredRelationalPersister<TRGT, ID> targetPersister) {
    			// adding index insert/update to strategy
    			targetPersister.<TARGETTABLE>getMapping().addShadowColumnInsert(new ShadowColumnValueProvider<TRGT, TARGETTABLE>() {

    				@Override
    				public boolean accept(TRGT entity) {
    					return currentInsertableListIndex.get() != null && currentInsertableListIndex.get().containsKey(entity);
    				}

    				@Override
    				public Set<Column<TARGETTABLE, ?>> getColumns() {
    					return Arrays.asHashSet(indexingColumn);
    				}

    				@Override
    				public Map<Column<TARGETTABLE, ?>, ?> giveValue(TRGT bean) {
    					Map<Column<TARGETTABLE, ?>, Object> result = new HashMap<>();
    					result.put(indexingColumn, currentInsertableListIndex.get().get(bean));
    					return result;
    				}
    			});
    		}

    		@Override
    		protected Set<? extends AbstractDiff<TRGT>> diff(Collection<TRGT> modified, Collection<TRGT> unmodified) {
    			return getDiffer().diffOrdered(unmodified, modified);
    		}

    		@Override
    		protected UpdateContext newUpdateContext(Duo<SRC, SRC> updatePayload) {
    			return new IndexedMappedAssociationUpdateContext(updatePayload);
    		}

    		@Override
    		protected void onAddedElements(UpdateContext updateContext, AbstractDiff<TRGT> diff) {
    			super.onAddedElements(updateContext, diff);
    			addNewIndexToContext((IndexedDiff<TRGT>) diff, (IndexedMappedAssociationUpdateContext) updateContext);
    		}

    		@Override
    		protected void onHeldElements(UpdateContext updateContext, AbstractDiff<TRGT> diff) {
    			super.onHeldElements(updateContext, diff);
    			addNewIndexToContext((IndexedDiff<TRGT>) diff, (IndexedMappedAssociationUpdateContext) updateContext);
    		}

    		private void addNewIndexToContext(IndexedDiff<TRGT> diff, IndexedMappedAssociationUpdateContext updateContext) {
    			Set<Integer> minus = Iterables.minus(diff.getReplacerIndexes(), diff.getSourceIndexes());
    			Integer index = Iterables.first(minus);
    			if (index != null) {
    				updateContext.getIndexUpdates().put(diff.getReplacingInstance(), index);
    			}
    		}

    		@Override
    		protected void insertTargets(UpdateContext updateContext) {
    			// we ask for entities insert as super does but we surround it by a ThreadLocal to fulfill List indexes which is required by
    			// the shadow column inserter (List indexes are given by default CollectionUpdater algorithm)
    			ThreadLocals.doWithThreadLocal(currentInsertableListIndex, ((IndexedMappedAssociationUpdateContext) updateContext)::getIndexUpdates,
    					(Runnable) () -> super.insertTargets(updateContext));
    		}

    		@Override
    		protected void updateTargets(UpdateContext updateContext, boolean allColumnsStatement) {
    			// we ask for entities update as super does but we surround it by a ThreadLocal to fulfill List indexes which is required by
    			// the shadow column updater (List indexes are given by default CollectionUpdater algorithm)
    			ThreadLocals.doWithThreadLocal(currentUpdatableListIndex, ((IndexedMappedAssociationUpdateContext) updateContext)::getIndexUpdates,
    					(Runnable) () -> super.updateTargets(updateContext, allColumnsStatement));
    		}

    		class IndexedMappedAssociationUpdateContext extends UpdateContext {

    			/** New indexes per entity */
    			private final Map<TRGT, Integer> indexUpdates = new IdentityHashMap<>();

    			public IndexedMappedAssociationUpdateContext(Duo<SRC, SRC> updatePayload) {
    				super(updatePayload);
    			}

    			public Map<TRGT, Integer> getIndexUpdates() {
    				return indexUpdates;
    			}
    		}
    	}

    }