/**

  * Copyright 2010 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.osedu.org/licenses/ECL-2.0

  *

  * 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.student.common.ui.client.mvc;

 import java.util.Date;

 import java.util.HashMap;

 import java.util.List;

 import java.util.Map;

 import java.util.Set;

 import org.kuali.student.common.assembly.data.Data;

 import org.kuali.student.common.assembly.data.Metadata;

 import org.kuali.student.common.assembly.data.ModelDefinition;

 import org.kuali.student.common.assembly.data.QueryPath;

 import org.kuali.student.common.assembly.data.Data.DataType;

 import org.kuali.student.common.assembly.data.Data.DataValue;

 import org.kuali.student.common.assembly.data.Data.Key;

 import org.kuali.student.common.assembly.data.Data.Property;

 import org.kuali.student.common.assembly.data.Data.Value;

 import org.kuali.student.common.assembly.data.HasChangeCallbacks.ChangeCallback;

 import org.kuali.student.common.assembly.data.HasChangeCallbacks.ChangeCallbackRegistration;

 import org.kuali.student.common.assembly.data.HasChangeCallbacks.ChangeType;

 import org.kuali.student.common.ui.client.configurable.mvc.FieldDescriptor;

 import org.kuali.student.common.ui.client.mvc.ModelChangeEvent.Action;

 import org.kuali.student.common.ui.client.validator.ClientDateParser;

 import org.kuali.student.common.ui.client.validator.DataModelValidator;

 import org.kuali.student.common.validation.dto.ValidationResultInfo;

 import org.kuali.student.common.validator.DateParser;

 import com.google.gwt.core.client.GWT;

 import com.google.gwt.event.shared.HandlerManager;

 import com.google.gwt.event.shared.HandlerRegistration;

 /**

  * The data model for Kuali Student.  Data is stored in a map of maps and is accessed through a QueryPath.

  * 

  * @author Kuali Student Team

  * @see QueryPath

  */

 /**

  * @author Kuali Student Team

  *

  */

 @SuppressWarnings("unchecked")

 public class DataModel implements Model {

     public interface QueryCallback<T> {

         void onResult(QueryPath path, T result);

     }

     private static final long serialVersionUID = 1L;

     private String modelName = "";

     private ModelDefinition definition;

     private DataModelValidator validator = new DataModelValidator();

     private HandlerManager handlers = new HandlerManager(this);

     private ChangeCallbackRegistration bridgeCallbackReg;

     private Data root;

     private String parentPath;    //Set this if DataModel's root element is nested in another data element.

     public DataModel() {

         // do nothing

     }

     public DataModel(String name) {

         this.modelName = name;

     }

     public DataModel(final ModelDefinition definition, final Data root) {

         this.definition = definition;

         this.root = root;

         validator.setDateParser((DateParser) GWT.create(ClientDateParser.class));

     }

     public String getModelName() {

         return modelName;

     }

     public void setModelName(String modelName) {

         this.modelName = modelName;

     }

     public <T> T get(final QueryPath path) {

         return (T) root.query(path);

     }

     public <T> T get(final String path) {

         return (T) get(QueryPath.parse(path));

     }

     /**

      * @return the root

      */

     public Data getRoot() {

         return root;

     }

     public void resetRoot() {

         root = null;

     }

     public void remove(final QueryPath path) {

         QueryPath parent = null;

         QueryPath leavePath = null;

         if (path != null && path.size() >= 2) {

             parent = path.subPath(0, path.size() - 1);

             leavePath = path.subPath(path.size() - 1, path.size());

             Object parentData = this.get(parent);

             if (parentData != null && parentData instanceof Data) {

                 ((Data) parentData).remove(

                         new Data.StringKey(leavePath.toString()));

             }

         } else if (path != null) {

             root.remove(new Data.StringKey(path.toString()));

         }

     }

     /** 

      * @param path The path in the data model

      * @return A map containing the path/value pairs for all matching elements, or an empty

      * map if no matching values found.

      */

     public Map<QueryPath, Object> query(final QueryPath path) {

         Map<QueryPath, Object> result = new HashMap<QueryPath, Object>();

         queryRelative(root, path, result);

         return result;

     }

     /** 

      * @param path The path in the data model

      * @return A map containing the path/value pairs for all matching elements, or an empty

      * map if no matching values found.

      */

     public Map<QueryPath, Object> query(final String path) {

         return query(QueryPath.parse(path));

     }

     /**

      * @param branch The data branch on which to perform the query

      * @param path   The path string relative to the root of the branch

      * @param result A map containing all matching paths and the corresponding data value. For a non-wildcard path

      *               this should return a single entry in the map of the path supplied and the corresponding value. For

      *               a path containing wildcard, an entry in the map will exist for each matching path and their corresponding values.

      *               Note: A path ending in a wild card will not match the _runtimeData element.

      */

     private void queryRelative(final Data branch, final QueryPath path, Map<QueryPath, Object> result) {

         //Should this add the entire branch to the result when query path is an empty string?

         Data d = branch;

         for (int i = 0; i < path.size(); i++) {

             if (d == null) {

                 // dead end

                 break;

             }

             final Key key = path.get(i);

             if (key.equals(Data.WILDCARD_KEY)) {

                 final QueryPath relative = path.subPath(i + 1, path.size());

                 if (!relative.isEmpty()) {

                     //Handle remaining path after wildcard

                     for (final Property p : d) {

                         if (p.getValueType().equals(Data.class)) {

                             queryRelative((Data) p.getValue(), relative, result);

                         }

                     }

                 } else {

                     //The wildcard is last element in path, so add all sub-elements to result

                     //The wildcard will not match a _runtimeData path

                     Set<Key> keys = d.keySet();

                     for (Key wildcardKey : keys) {

                         if (!("_runtimeData".equals(wildcardKey.get()))) {

                             QueryPath wildcardPath = path.subPath(0, path.size() - 1);

                             wildcardPath.add(wildcardKey);

                             result.put(wildcardPath, d.get(wildcardKey));

                         }

                     }

                 }

                 break; //No need to continue once we process wildcard

             } else if (i < path.size() - 1) {

                 d = d.get(key);

             } else {

                 final QueryPath resultPath = d.getQueryPath();

                 resultPath.add(key);

                 Object resultValue = d.get(key);

                 //If query is against DataModel whose root element is child of another data object, 

                 //need to strip of the parent path so result path is relative to root of child element

                 if (parentPath != null) {

                     String relativePath = resultPath.toString();

                     if (relativePath.contains("/")) {

                         relativePath = relativePath.substring(parentPath.length());

                         result.put(QueryPath.parse(relativePath), resultValue);

                     }else{

                        result.put(resultPath, resultValue); 

                     }

                 } else {

                     result.put(resultPath, resultValue);

                 }

             }

         }

     }

     public void set(final QueryPath path, final Data value) {

         set(path, new Data.DataValue(value));

     }

     public void set(final QueryPath path, final Integer value) {

         set(path, new Data.IntegerValue(value));

     }

     public void set(final QueryPath path, final String value) {

         set(path, new Data.StringValue(value));

     }

     public void set(final QueryPath path, final Long value) {

         set(path, new Data.LongValue(value));

     }

     public void set(final QueryPath path, final Short value) {

         set(path, new Data.ShortValue(value));

     }

     public void set(final QueryPath path, final Double value) {

         set(path, new Data.DoubleValue(value));

     }

     public void set(final QueryPath path, final Float value) {

         set(path, new Data.FloatValue(value));

     }

     public void set(final QueryPath path, final Boolean value) {

         set(path, new Data.BooleanValue(value));

     }

     public void set(final QueryPath path, final Date value) {

         set(path, new Data.DateValue(value));

     }

     public void set(final QueryPath path, final Value value) {

         definition.ensurePath(root, path, value instanceof DataValue);

         if (path.size() > 1) {

             final QueryPath q = path.subPath(0, path.size() - 1);

             final Data d = root.query(q);

             d.set(path.get(path.size() - 1), value);

         } else {

             root.set(path.get(0), value);

         }

     }

     public DataType getType(final QueryPath path) {

         return definition.getType(path);

     }

     public Metadata getMetadata(final QueryPath path) {

         return definition.getMetadata(path);

     }

     /**

      * Set the top level data for this DataModel

      * @param root the root to set

      */

     public void setRoot(final Data root) {

         if (bridgeCallbackReg != null) {

             bridgeCallbackReg.remove();

         }

         this.root = root;

         bridgeCallbackReg = root.addChangeCallback(new ChangeCallback() {

             @Override

             public void onChange(ChangeType type, QueryPath path) {

                 Action action = null;

                 if (type == ChangeType.ADD) {

                     action = Action.ADD;

                 } else if (type == ChangeType.REMOVE) {

                     action = Action.REMOVE;

                 } else if (type == ChangeType.UPDATE) {

                     action = Action.UPDATE;

                 }

                 handlers.fireEvent(new DataModelChangeEvent(action, DataModel.this, path));

             }

         });

         handlers.fireEvent(new DataModelChangeEvent(Action.RELOAD, this, new QueryPath()));

     }

     @Override

     public HandlerRegistration addModelChangeHandler(ModelChangeHandler handler) {

         return handlers.addHandler(ModelChangeEvent.TYPE, handler);

     }

     public ModelDefinition getDefinition() {

         return definition;

     }

     public void setDefinition(ModelDefinition definition) {

         this.definition = definition;

     }

     public String getParentPath() {

         return parentPath;

     }

     /**

      * If the root element for this is a child of another data object, then the parent

      * path must be set to the path where this child data object can be found.

      *

      * @param parentPath

      */

     public void setParentPath(String parentPath) {

         this.parentPath = parentPath;

     }

     /**

      * Validates this data model against its ModelDefinition/Metadata and returns the result

      * to the callback

      * @param callback

      */

     public void validate(final Callback<List<ValidationResultInfo>> callback) {

         List<ValidationResultInfo> result = validator.validate(this);

         callback.exec(result);

     }

     /**

      * Validates this data model against the next state in its ModelDefinition and returns the result

      * to the callback

      * @param callback

      */

     public void validateNextState(final Callback<List<ValidationResultInfo>> callback) {

         List<ValidationResultInfo> result = validator.validateNextState(this);  // loads missingField result info [KSCM-250]

         callback.exec(result);

     }

     /**

      * Validates this data model against the given metadata and returns the result

      * to the callback

      * @param metadata

      * @param callback

      */

     public void validateForMetadata(Metadata metadata, final Callback<List<ValidationResultInfo>> callback) {

         List<ValidationResultInfo> result = validator.validateForMetadata(metadata, this);

         callback.exec(result);

     }

     /**

      * Validates a single field

      * @param fd

      * @param callback

      */

     public void validateField(FieldDescriptor fd, final Callback<List<ValidationResultInfo>> callback) {

         List<ValidationResultInfo> result = validator.validate(fd, this);

         callback.exec(result);

     }

     /**

      * Checks to see if data exists for the path passed in

      * @param sPath

      * @return

      */

     public boolean isValidPath(String sPath) {

         QueryPath path = QueryPath.parse(sPath);

         boolean result = false;

         Data root = this.getRoot();

         for (int i = 0; i < path.size(); i++) {

             Data.Key key = path.get(i);

             if (!root.containsKey(key)) {

                 result = false;

                 break;

             } else if (i < path.size() - 1) {

                 root = (Data) root.get(key);

             } else {

                 result = true;

                 break;

             }

         }

         return result;

     }

 }