package models.terms.meta;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

import models.algebra.Expression;
import models.algebra.Variable;
import models.terms.RDLTerm;

public class MetaDynamicDependency extends MetaDependency implements MetaDynamicTerm {

	private final MetaTermGenerator termGenerator;
	
	public MetaDynamicDependency(MetaTermGenerator termGenerator) {
		this.termGenerator = termGenerator;
	}
	
	public MetaDynamicDependency(MetaTermGenerator termGenerator, List<? extends RDLTerm> terms) {
		this.termGenerator = termGenerator;
		this.dependingTerm = terms.size() > 0 ? terms.get(0) : null;
		this.dependedTerms = terms.size() > 1 ? terms.stream().skip(1).toList() : List.of();
		for (RDLTerm term : terms) {
			addChild(term);
		}
	}
	
	public MetaDynamicDependency(MetaTermGenerator termGenerator, RDLTerm ...terms) {
		this(termGenerator, Arrays.asList(terms));
	}
	
	@Override
	public MetaRDLTerm generate(int depth, Map<Variable, Object> context) {
		// TODO 自動生成されたメソッド・スタブ
		return null;
	}

	@Override
	public MetaDependency generate(int depth, int maxIndex, int maxDepth, Map<Variable, Object> context) {
		if (maxIndex < 2) return null;
		RDLTerm dependingTerm = this.dependingTerm == null ? termGenerator.generate(0, depth, maxIndex, maxDepth, context) : this.dependingTerm;
		while (dependingTerm instanceof MetaDynamicTerm dynamicTerm) {
			dependingTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context);
		}
		List<RDLTerm> dependedTerms = new ArrayList<>();
		int staticSize = this.dependedTerms == null ? 0 : this.dependedTerms.size();
		for (int i = 0; i < Math.min(maxIndex - 1, staticSize); i++) {
			dependedTerms.add(this.dependedTerms.get(i));
		}
		for (int i = staticSize; i < maxIndex - 1; i++) {
			RDLTerm generatedTerm = termGenerator.generate(i + 1, depth, maxIndex, maxDepth, context);
			while (generatedTerm instanceof MetaDynamicTerm dynamicTerm) {
				generatedTerm = dynamicTerm.generate(depth + 1, maxIndex, maxDepth, context);
			}
			dependedTerms.add(generatedTerm);
		}
		return new MetaDependency(dependingTerm, dependedTerms);
	}
	
	
	@Override
	protected Set<MatchConstraint> isMatchedBy(RDLTerm another, MatchConstraint constraint, int depth) {
		return null;
	}

	@Override
	protected RDLTerm substitute(Map<Variable, RDLTerm> binding, int depth) {
		// TODO 自動生成されたメソッド・スタブ
		return null;
	}

	
	@Override
	public String toString() {
		if (dependingTerm != null) {
			return "[" + 
				getChild(0).toString() + " : " + 
					getChildren().stream().skip(1).map(Expression::toString).collect(Collectors.joining(",")) + 
					" ...? ]";
		}
		return "[ ...? ]";
	}
}