/**
    * Copyright 2005-2011 The Kuali Foundation
    *
    * Licensed under the Educational Community License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    * http://www.opensource.org/licenses/ecl2.php
    *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.kuali.rice.krms.api.repository.proposition;
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.List;
  
  import javax.xml.bind.annotation.XmlAccessType;
  import javax.xml.bind.annotation.XmlAccessorType;
  import javax.xml.bind.annotation.XmlAnyElement;
  import javax.xml.bind.annotation.XmlElement;
  import javax.xml.bind.annotation.XmlElementWrapper;
  import javax.xml.bind.annotation.XmlRootElement;
  import javax.xml.bind.annotation.XmlType;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.core.api.CoreConstants;
  import org.kuali.rice.core.api.mo.AbstractDataTransferObject;
  import org.kuali.rice.core.api.mo.ModelBuilder;
  import org.kuali.rice.krms.api.repository.LogicalOperator;
  import org.kuali.rice.krms.api.repository.rule.RuleDefinition;
  
  /**
   * Concrete model object implementation of KRMS Proposition. 
   * Immutable. 
   * Instances of Proposition can be (un)marshalled to and from XML.
   *
   * There are three main types of Propositions:
   *    1. Compound Propositions - a proposition consisting of other propositions
   *    	 and a boolean algebra operator (AND, OR) defining how to evaluate those propositions.
   *    2. Parameterized Propositions - a proposition which is parameterized by some set of values, 
   *    	 evaluation logic is implemented by hand and returns true or false
   *    3. Simple Propositions - a proposition of the form lhs op rhs where 
   *    	lhs=left-hand side, rhs=right-hand side, and op=operator
   * Propositions are reference by a rule or another proposition (in the case of compound propositions).
   * Propositions are never re-used across multiple rules.
   * Each proposition can have zero or more parameters. The proposition parameter is the primary 
   * data element used to define the proposition.  (@see PropositionParameter)
   * 
   * @see PropositonContract
   * @see PropositionParameterContract
   */
  @XmlRootElement(name = PropositionDefinition.Constants.ROOT_ELEMENT_NAME)
  @XmlAccessorType(XmlAccessType.NONE)
  @XmlType(name = PropositionDefinition.Constants.TYPE_NAME, propOrder = {
  		PropositionDefinition.Elements.ID,
  		PropositionDefinition.Elements.DESC,
          PropositionDefinition.Elements.RULE_ID,
          PropositionDefinition.Elements.TYPE_ID,
  		PropositionDefinition.Elements.PROP_TYPE_CODE,
  		PropositionDefinition.Elements.PARAMETERS,									// xml element name differs from class property name
  		PropositionDefinition.Elements.CMPND_OP_CODE,
  		PropositionDefinition.Elements.CMPND_COMPONENTS,
          CoreConstants.CommonElements.VERSION_NUMBER,
  		CoreConstants.CommonElements.FUTURE_ELEMENTS
  })
  public final class PropositionDefinition extends AbstractDataTransferObject implements PropositionDefinitionContract {
  	private static final long serialVersionUID = 2783959459503209577L;
  
  	// TODO: change this to field name to id
  	@XmlElement(name = Elements.ID, required=true)
  	private String id;
  	
  	@XmlElement(name = Elements.DESC, required=true)
  	private String description;
  	
  	@XmlElement(name = Elements.TYPE_ID, required=true)
  	private String typeId;
  	
      @XmlElement(name = Elements.RULE_ID, required=true)
      private String ruleId;
      
      @XmlElement(name = Elements.PROP_TYPE_CODE, required=true)
  	private String propositionTypeCode;
  
  	@XmlElementWrapper(name = Elements.PARAMETERS)
  	@XmlElement(name = Elements.PARAMETER, required=false)
  	private List<PropositionParameter> parameters;
  	
  	@XmlElement(name = Elements.CMPND_OP_CODE, required=false)
  	private String compoundOpCode;
  	
  	@XmlElementWrapper(name = Elements.CMPND_COMPONENTS, required=false)
 	@XmlElement(name = Elements.CMPND_COMPONENT, required=false)
 	private List<PropositionDefinition> compoundComponents;
 	
     @XmlElement(name = CoreConstants.CommonElements.VERSION_NUMBER, required = false)
     private final Long versionNumber;
     	
 	@SuppressWarnings("unused")
     @XmlAnyElement
     private final Collection<org.w3c.dom.Element> _futureElements = null;
 	
 	
 	 /** 
      * This constructor should never be called.  It is only present for use during JAXB unmarshalling. 
      */
     private PropositionDefinition() {
     	this.id = null;
     	this.description = null;
     	this.typeId = null;
     	this.propositionTypeCode = null;
     	this.parameters = null;
     	this.compoundOpCode = null;
     	this.compoundComponents = null;
         this.versionNumber = null;
     }
     
     /**
 	 * Constructs a KRMS Proposition from the given builder.  
 	 * This constructor is private and should only ever be invoked from the builder.
 	 * 
 	 * @param builder the Builder from which to construct the KRMS Proposition
 	 */
     private PropositionDefinition(Builder builder) {
         this.id = builder.getId();
         this.description = builder.getDescription();
         this.ruleId = builder.getRuleId();
         this.typeId = builder.getTypeId();
         this.propositionTypeCode = builder.getPropositionTypeCode();
         
         // Build parameter list
         List<PropositionParameter> paramList = new ArrayList<PropositionParameter>();
         for (PropositionParameter.Builder b : builder.parameters){
         	paramList.add(b.build());
         }
         this.parameters = Collections.unmodifiableList(paramList);
         
         // Build Compound Proposition properties
         this.compoundOpCode = builder.getCompoundOpCode();
         List <PropositionDefinition> componentList = new ArrayList<PropositionDefinition>();
         if (builder.compoundComponents != null){
         	for (PropositionDefinition.Builder b : builder.compoundComponents){
         		componentList.add(b.build());
         	}
             this.compoundComponents = Collections.unmodifiableList(componentList);
         }
         this.versionNumber = builder.getVersionNumber();
     }
     
 	@Override
 	public String getId() {
 		return this.id;
 	}
 
 	@Override
 	public String getDescription() {
 		return this.description;
 	}
 
     /**
      * @return the ruleId
      */
     public String getRuleId() {
         return this.ruleId;
     }
 
 	@Override
 	public String getTypeId() {
 		return this.typeId;
 	}
 
 	@Override
 	public String getPropositionTypeCode() {
 		return this.propositionTypeCode; 
 	}
 
 	@Override
 	public List<PropositionParameter> getParameters() {
 		return this.parameters; 
 	}
 
 	@Override
 	public String getCompoundOpCode() {
 		return this.compoundOpCode; 
 	}
 
 	@Override
 	public List<PropositionDefinition> getCompoundComponents() {
 		return this.compoundComponents; 
 	}
 
     @Override
     public Long getVersionNumber() {
         return versionNumber;
     }
         
 	/**
      * This builder is used to construct instances of KRMS Proposition.  It enforces the constraints of the {@link PropositionDefinitionContract}.
      */
     public static class Builder implements PropositionDefinitionContract, ModelBuilder, Serializable {
     	private static final long serialVersionUID = -6889320709850568900L;
 		
         private String id;
         private String description;
         private String ruleId;
         private String typeId;
         private String propositionTypeCode;
         private List<PropositionParameter.Builder> parameters;
         private String compoundOpCode;
         private List<PropositionDefinition.Builder> compoundComponents;
         private RuleDefinition.Builder rule;
         private Long versionNumber;
 
 		/**
 		 * Private constructor for creating a builder with all of it's required attributes.
 		 * @param typeId TODO
 		 */
         private Builder(String propId, String propTypeCode, String ruleId, String typeId, List<PropositionParameter.Builder> parameters) {
         	setId(propId);
 			setPropositionTypeCode(propTypeCode);
 			setRuleId(ruleId);
 			setTypeId(typeId);
 			setParameters(parameters);
         }
         
         public Builder compoundOpCode(String opCode){
         	setCompoundOpCode(opCode);
         	return this;
         }
         
         public Builder compoundComponents (List<PropositionDefinition.Builder> components){
         	setCompoundComponents(components);
         	return this;
         }
  
         public static Builder create(String propId, String propTypeCode, String ruleId, String typeId, List<PropositionParameter.Builder> parameters){
         	return new Builder(propId, propTypeCode, ruleId, typeId, parameters);
         }
         
         /**
          * Creates a builder by populating it with data from the given {@link PropositionDefinitionContract}.
          * 
          * @param contract the contract from which to populate this builder
          * @return an instance of the builder populated with data from the contract
          */
         public static Builder create(PropositionDefinitionContract contract) {
         	if (contract == null) {
                 throw new IllegalArgumentException("contract is null");
             }
         	List <PropositionParameter.Builder> paramBuilderList = new ArrayList<PropositionParameter.Builder>();
         	if (contract.getParameters() != null){
         		for (PropositionParameterContract paramContract : contract.getParameters()){
         			PropositionParameter.Builder myBuilder = PropositionParameter.Builder.create(paramContract);
         			paramBuilderList.add(myBuilder);
         		}
         	}
             Builder builder =  new Builder(contract.getId(), contract.getPropositionTypeCode(), contract.getRuleId(), contract.getTypeId(), paramBuilderList);
             
         	List <PropositionDefinition.Builder> componentBuilderList = new ArrayList<PropositionDefinition.Builder>();
         	if (contract.getCompoundComponents() != null) {
         		for (PropositionDefinitionContract cContract : contract.getCompoundComponents()){
         			PropositionDefinition.Builder pBuilder = PropositionDefinition.Builder.create(cContract);
         			componentBuilderList.add(pBuilder);
         		}
                 builder.setCompoundComponents(componentBuilderList);
         	}
         	builder.setCompoundOpCode(contract.getCompoundOpCode());
             builder.setDescription(contract.getDescription());
             builder.setVersionNumber(contract.getVersionNumber());
             return builder;
         }
 
 		/**
 		 * Sets the value of the id on this builder to the given value.
 		 * 
 		 * @param id the id value to set
 		 */
 
         public void setId(String propId) {
             if (propId != null && StringUtils.isBlank(propId)) {
                 throw new IllegalArgumentException("proposition id must not be blank");            	
             }
 			this.id = propId;
 		}
 
 		public void setDescription(String desc) {
 			this.description = desc;
 		}
 		
         public void setTypeId(String typeId) {
             this.typeId = typeId;
         }
         
         public void setRuleId(String ruleId) {
             this.ruleId = ruleId;
         }
         
         public void setRule(RuleDefinition.Builder rule) {
             if (rule != null && !StringUtils.isBlank(rule.getId())) {
                 setRuleId(rule.getId());
             }
             this.rule = rule;
         }
         
 		public void setPropositionTypeCode(String propTypeCode) {
 			if (StringUtils.isBlank(propTypeCode)) {
                 throw new IllegalArgumentException("proposition type code is blank");
 			}
 			if (!PropositionType.VALID_TYPE_CODES.contains(propTypeCode)) {
                 throw new IllegalArgumentException("invalid proposition type code");
 			}
 			this.propositionTypeCode = propTypeCode;
 		}
 		
 		public void setParameters(List<PropositionParameter.Builder> parameters) {
 			// compound propositions have empty parameter lists
 			// Simple propositions must have a non-empty parameter list
 			if (parameters == null || parameters.isEmpty()){
 				this.parameters = Collections.unmodifiableList(new ArrayList<PropositionParameter.Builder>());
 			} else {
 			    this.parameters = Collections.unmodifiableList(parameters);
 			}
 		}
 		
 		public void setCompoundOpCode(String opCode){
 			if (StringUtils.isBlank(opCode)){ return; }
 			if (!LogicalOperator.OP_CODES.contains(opCode)){
 				throw new IllegalArgumentException("invalid opCode value");
 			}
 			this.compoundOpCode = opCode;
 		}
 
 		public void setCompoundComponents(List<PropositionDefinition.Builder> components){
 			if (components == null || components.isEmpty()){
 				this.compoundComponents = Collections.unmodifiableList(new ArrayList<PropositionDefinition.Builder>());
 				return;
 			}
 			this.compoundComponents = Collections.unmodifiableList(components);
 		}
 		
         public void setVersionNumber(Long versionNumber){
             this.versionNumber = versionNumber;
         }
         
 		@Override
 		public String getId() {
 			return id;
 		}
 
 		@Override
 		public String getDescription() {
 			return description;
 		}
 		
 		@Override
 		public String getRuleId() {
 		    return ruleId;
 		}
 
 		@Override
 		public String getTypeId() {
 			return typeId;
 		}
 
 		@Override
 		public String getPropositionTypeCode() {
 			return propositionTypeCode;
 		}
 		
 		@Override
 		public List<PropositionParameter.Builder> getParameters() {
 			return parameters;
 		}
 
 		@Override
 		public String getCompoundOpCode() {
 			return compoundOpCode;
 		}
 		
 		@Override
 		public List<PropositionDefinition.Builder> getCompoundComponents() {
 			return compoundComponents;
 		}
 
         @Override
         public Long getVersionNumber() {
             return versionNumber;
         }
 
 		/**
 		 * Builds an instance of a Proposition based on the current state of the builder.
 		 * 
 		 * @return the fully-constructed Proposition
 		 */
         @Override
         public PropositionDefinition build() {
             return new PropositionDefinition(this);
         }
 		
     }
 	
 	/**
 	 * Defines some internal constants used on this class.
 	 */
 	static class Constants {
 		final static String ROOT_ELEMENT_NAME = "proposition";
 		final static String TYPE_NAME = "PropositionType";
 	}
 	
 	/**
 	 * A private class which exposes constants which define the XML element names to use
 	 * when this object is marshalled to XML.
 	 */
 	public static class Elements {
 		final static String ID = "id";
 		final static String DESC = "description";
         final static String RULE_ID = "ruleId";
 		final static String TYPE_ID = "typeId";
 		final static String PROP_TYPE_CODE = "propositionTypeCode";
 		final static String PARAMETER = "parameter";
 		final static String PARAMETERS = "parameters";
 		final static String CMPND_OP_CODE = "compoundOpCode";
 		final static String CMPND_COMPONENTS = "compoundComponents";
 		final static String CMPND_COMPONENT = "proposition";
 	}
 
 	
 }