package models.dataConstraintModel;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import models.algebra.Constant;
import models.algebra.Expression;
import models.algebra.Symbol;
import models.algebra.Term;
import parser.Parser;

public class JsonTerm extends Term {
	private Map<String, Integer> keyToIndex = new HashMap<>();

	public JsonTerm() {
		super(new Symbol("json", -1));
		setType(DataConstraintModel.typeJson);
	}
	
	public void addMember(String key, Expression value) {
		if (keyToIndex.containsKey(key)) {
			setChild(keyToIndex.get(key), value);
		} else {
			keyToIndex.put(key, getChildren().size());
			addChild(value);
		}
	}
	
	public Set<String> keySet() {
		return keyToIndex.keySet();
	}

	public Expression get(String key) {
		if (keyToIndex.get(key) == null) return null;
		return getChild(keyToIndex.get(key));
	}

	public Expression get(Constant key) {
		if (keyToIndex.get(key.getValue()) == null) return null;
		return getChild(keyToIndex.get(key.getValue()));
	}
	
	@Override
	public Expression unify(Expression another) {
		if (another instanceof JsonTerm) {
			JsonTerm anotherTerm = (JsonTerm) another;
			JsonTerm unifiedTerm = new JsonTerm();
			Set<String> keySet = new HashSet<>();
			keySet.addAll(this.keySet());
			keySet.addAll(anotherTerm.keySet());			
			for (String key: keySet) {
				if (this.keySet().contains(key)) {
					if (anotherTerm.keySet().contains(key)) {
						unifiedTerm.addMember(key, this.get(key).unify(anotherTerm.get(key)));
					} else {
						unifiedTerm.addMember(key, this.get(key));
					}
				} else {
					unifiedTerm.addMember(key, anotherTerm.get(key));
				}
			}
			return unifiedTerm;
		}
		return this;
	}
	
	@Override
	public Object clone() {
		JsonTerm newTerm = new JsonTerm();
		for (Expression e: children) {
			newTerm.addChild((Expression) e.clone());
		}
		newTerm.keyToIndex = new HashMap<String, Integer>(keyToIndex);
		return newTerm;
	}
	
	public String toString() {
		String jsonStr = "{";
		String delim = "";
		for (String key: keyToIndex.keySet()) {
			jsonStr += delim + Parser.DOUBLE_QUOT + key + Parser.DOUBLE_QUOT + ": " + getChild(keyToIndex.get(key)).toString();
			delim = ", ";
		}
		return jsonStr + "}";
	}

	private String toString(int indentLevel) {
		StringBuilder jsonStr = new StringBuilder("{");
		String delim = "\n";
		String indent = "    ".repeat(indentLevel + 1);

		for (String key : keyToIndex.keySet()) {
			jsonStr.append(delim).append(indent)
					.append(Parser.DOUBLE_QUOT).append(key).append(Parser.DOUBLE_QUOT).append(": ")
					.append(formatValue(getChild(keyToIndex.get(key)), indentLevel + 1));
			delim = ",\n";
		}

		jsonStr.append("\n").append("    ".repeat(indentLevel)).append("}");
		return jsonStr.toString();
	}

	private String formatValue(Expression value, int indentLevel) {
		if (value instanceof JsonTerm) {
			return ((JsonTerm) value).toString(indentLevel);
		} else {
			return value.toString(); // Handle constants or other types of expressions
		}
	}
}