package foundation.variant.expression;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import foundation.util.Util;
import foundation.variant.provider.DataEvent;
import foundation.variant.provider.IVariantsConsumer;
import foundation.variant.provider.IVariantsProvider;

public class VariantExpression implements Iterable<VariantSegment>, IVariantParseListener, IExpression, IVariantsConsumer {
	
	protected static Logger logger;
	protected List<Segment> segments;
	protected VariantList variantList;
	protected VariantParser parser;
	
	static {
		logger = LogManager.getLogger(VariantExpression.class);
	}
	
	private VariantExpression(int size) throws Exception {
		if (size <= 0) {
			size = 8;
		}
		
		segments = new ArrayList<Segment>(size);
		variantList = new VariantList();
	}
	
	public VariantExpression() {
		segments = new ArrayList<Segment>(8);
		variantList = new VariantList();
		parser = new VariantParser(this);
	}
	
	public VariantExpression(String String) throws Exception {
		this(String, 0);
	}
	
	public VariantExpression(String String, int size) throws Exception {
		this(size);
		
		VariantParser parser = new VariantParser(this);
		parser.parse(String);
	}

	public VariantExpression newInstance() throws Exception {
		int size = segments.size();
		VariantExpression instance = new VariantExpression(size);
		
		Segment segment;
		VariantSegment param;
		
		for (int i = 0; i < size; i++) {
			segment = segments.get(i);
			
			if (segment instanceof VariantSegment) {
				param = (VariantSegment) segment;
				String name = param.getName();
				
				if (instance.variantList.contains(param.getName())) {
					instance.segments.add(instance.variantList.get(name));
				}
				else {
					segment = segment.newInstance();
					instance.segments.add(segment);
					instance.variantList.add(name, (VariantSegment) segment);
				}
			}
			else {
				segment = segment.newInstance();
				instance.segments.add(segment);
			}
		}
		
		return instance;
	}
	
	public void parseOneLine(String value) throws Exception {
		parser.parse(value);
	}
	
	public String tryGetString() throws Exception {
		for (VariantSegment variant : variantList) {
			if (variant.isEmpty()) {
				throw new Exception("empty variant param: " + variant.getName());
			}
		}
		
		return getString();
	}
	
	public String getString() {
		StringBuilder result = new StringBuilder();
		
		int n = segments.size();
		Segment segment;
		String value;
		
		for (int i = 0; i < n; i++) {
			segment = segments.get(i);
			value = segment.getValue();
			
			result.append(value);
		}
		
		return result.toString();
	}
	
	@Override
	public void onSegment(String value) {
		if (Util.isEmpty(value)) {
			return;
		}
		
		Segment segment = new StringSegment(value);
		segments.add(segment);
	}

	@Override
	public void addVariant(String name) throws Exception {
		if (Util.isEmpty(name)) {
			return;
		}
		
		if (variantList.contains(name)) {
			VariantSegment segment = variantList.get(name);
			segments.add(segment);
		}
		else {
			VariantSegment segment = new VariantSegment(name);
			segments.add(segment);
			variantList.add(name, segment);
		}	
	}
	
	public VariantSegment getVariant(String name) {
		return variantList.get(name);
	}

	public Iterator<VariantSegment> iterator() {
		return variantList.getItemList().iterator();
	}

	@Override
	public VariantList getVariantList() {
		return variantList;
	}

	public boolean isVariantListEmpty() {
		return variantList.isEmpty();
	}
	
	public void clearVariantValues() {
		for (VariantSegment variant: variantList) {
			variant.clearValue();
		}		
	}

	public boolean containsVariant(String name) {
		return variantList.contains(name);
	}
	
	@Override
	public boolean isVariantNull(String name) {
		VariantSegment segment = getVariant(name);
		return segment.isEmpty();
	}
	
	public List<Segment> getSegments() {
		return segments;
	}

	@Override
	public Set<String> getVariantNames() {
		return variantList.getKeySet();
	}

	@Override
	public void setVariants(DataEvent dataEvent, IVariantsProvider... providers) throws Exception {
		for (VariantSegment param: variantList) {
			String name = param.getName();
			
			for (IVariantsProvider provider: providers) {
				if (provider.containsVariant(name)) {
					Object value = provider.getVariantValue(dataEvent, name);
					param.setValue(String.valueOf(value));
				}
			}
		}
	}

	@Override
	public void setVariant(DataEvent dataEvent, String name, Object value) throws Exception {
		VariantSegment param = variantList.get(name);
		
		if (param == null) {
			return;
		}
		
		param.setValue(String.valueOf(value)); 
	}
	
	public void clear() {
		segments.clear();
		variantList.clear();
	}
	
	public void setFlag_Variant(char value) {
		parser.setFlag_Variant(value);
	}

	public void setFlag_LeftQuote(char value) {
		parser.setFlag_LeftQuote(value);
	}

	public void setFlag_RightQuote(char value) {
		parser.setFlag_RightQuote(value);
	}

	@Override
	public String toString() {
		return getString();
	}
	
}