/*
    * #%L
    * prolobjectlink-jpi-jpl
    * %%
    * Copyright (C) 2019 Prolobjectlink Project
    * %%
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU Lesser General Public License as
    * published by the Free Software Foundation, either version 2.1 of the
   * License, or (at your option) any later version.
   * 
   * This program 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 Lesser Public License for more details.
   * 
   * You should have received a copy of the GNU General Lesser Public
   * License along with this program.  If not, see
   * <http://www.gnu.org/licenses/lgpl-2.1.html>.
   * #L%
   */
  package io.github.prolobjectlink.prolog.jpl;
  
  import static io.github.prolobjectlink.prolog.PrologTermType.CUT_TYPE;
  import static io.github.prolobjectlink.prolog.PrologTermType.DOUBLE_TYPE;
  import static io.github.prolobjectlink.prolog.PrologTermType.FLOAT_TYPE;
  import static io.github.prolobjectlink.prolog.PrologTermType.INTEGER_TYPE;
  import static io.github.prolobjectlink.prolog.PrologTermType.LONG_TYPE;
  
  import java.util.Map;
  
  import io.github.prolobjectlink.prolog.AbstractTerm;
  import io.github.prolobjectlink.prolog.PrologList;
  import io.github.prolobjectlink.prolog.PrologProvider;
  import io.github.prolobjectlink.prolog.PrologQuery;
  import io.github.prolobjectlink.prolog.PrologTerm;
  import jpl.Atom;
  import jpl.Query;
  import jpl.Term;
  
  /**
   * 
   * @author Jose Zalacain
   * @since 1.0
   */
  abstract class JplTerm extends AbstractTerm implements PrologTerm {
  
  	protected Term value;
  
  	static final Term JPL_TRUE = new Atom("true");
  
  	protected JplTerm(int type, PrologProvider provider) {
  		super(type, provider);
  	}
  
  	protected JplTerm(int type, PrologProvider provider, Term value) {
  		super(type, provider);
  		this.value = value;
  	}
  
  	public final boolean isAtom() {
  		return value.isAtom();
  	}
  
  	public final boolean isNumber() {
  		return isFloat() || isDouble() || isInteger() || isLong();
  	}
  
  	public final boolean isFloat() {
  		return type == FLOAT_TYPE && value.isFloat();
  	}
  
  	public final boolean isDouble() {
  		return type == DOUBLE_TYPE;
  	}
  
  	public final boolean isInteger() {
  		return type == INTEGER_TYPE && value.isInteger();
  	}
  
  	public final boolean isLong() {
  		return type == LONG_TYPE;
  	}
  
  	public final boolean isVariable() {
  		return value.isVariable();
  	}
  
  	public final boolean isList() {
  		if (!isVariable()) {
  			return value.equals(JplList.EMPTY) || value.hasFunctor(".", 2);
  		}
  		return false;
  	}
  
  	public final boolean isStructure() {
  		return isCompound() && !isList();
  	}
  
 	public final boolean isNil() {
 		if (!isVariable() && !isNumber()) {
 			return value.hasFunctor("nil", 0);
 		}
 		return false;
 	}
 
 	public final boolean isEmptyList() {
 		return value.equals(JplList.EMPTY);
 	}
 
 	public final boolean isEvaluable() {
 		if (!isVariable() && !isList() && !isNumber() && getArity() == 2) {
 			String key = "LIST";
 			String stringQuery = "findall(OP,current_op(_,_,OP)," + key + ")";
 			JplEngine engine = (JplEngine) provider.newEngine();
 			PrologQuery query = new JplQuery(engine, engine.getCache(), stringQuery);
 			Map<String, PrologTerm>[] solution = query.allVariablesSolutions();
 			for (Map<String, PrologTerm> map : solution) {
 				for (PrologTerm operatorList : map.values()) {
 					if (!operatorList.isVariable() && operatorList.isList()) {
 						PrologList l = (PrologList) operatorList;
 						for (PrologTerm operator : l) {
 							if (operator.getFunctor().equals(getFunctor())) {
 								return true;
 							}
 						}
 					}
 				}
 			}
 		}
 		return false;
 	}
 
 	public final boolean isAtomic() {
 		return !isCompound() && !isList();
 	}
 
 	public final boolean isCompound() {
 		return value.isCompound() && !isAtom();
 	}
 
 	public final boolean isTrueType() {
 		return value.isJTrue();
 	}
 
 	public final boolean isFalseType() {
 		return value.isJFalse();
 	}
 
 	public final boolean isNullType() {
 		return value.isJNull();
 	}
 
 	public final boolean isVoidType() {
 		return value.isJVoid();
 	}
 
 	public final boolean isObjectType() {
 		return value.isJObject();
 	}
 
 	public final boolean isReference() {
 		return value.isJRef();
 	}
 
 	public final PrologTerm getTerm() {
 		return this;
 	}
 
 	public final boolean unify(PrologTerm o) {
 		return unify(fromTerm(o, Term.class));
 	}
 
 	private final boolean unify(Term o) {
 		String q = "unify_with_occurs_check(" + value + "," + o + ")";
 		Query query = new Query(q);
 		boolean result = query.hasSolution();
 		query.close();
 		return result;
 	}
 
 	public final int compareTo(PrologTerm o) {
 
 		String key = "Order";
 		Term term = fromTerm(o, Term.class);
 		String arguments = key + "," + value + "," + term;
 		Query query = new Query("compare(" + arguments + ")");
 
 		query.open();
 		Term order = (Term) query.getSolution().get(key);
 		query.close();
 
 		if (order.hasFunctor("<", 0)) {
 			return -1;
 		} else if (order.hasFunctor(">", 0)) {
 			return 1;
 		}
 
 		return 0;
 
 	}
 
 	public int hashCode() {
 		final int prime = 31;
 		int result = 1;
 		result = prime * result + type;
 		// Term not implement hashCode()
 		result = prime * result + ((value == null) ? 0 : value.toString().hashCode());
 		return result;
 	}
 
 	public boolean equals(Object obj) {
 		if (this == obj)
 			return true;
 		if (obj == null)
 			return false;
 		JplTerm other = (JplTerm) obj;
 		if (value == null) {
 			if (other.value != null)
 				return false;
 		} else if (!unify(other.value)) {
 			return false;
 		}
 		return true;
 	}
 
 	public String toString() {
 		if (type == CUT_TYPE) {
 			return getFunctor();
 		}
 		return "" + value + "";
 	}
 
 }