/**

  * 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.core.api.uif;

 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.w3c.dom.Element;

 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.XmlElements;

 import javax.xml.bind.annotation.XmlRootElement;

 import javax.xml.bind.annotation.XmlType;

 import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;

 import java.util.ArrayList;

 import java.util.Collection;

 import java.util.Collections;

 import java.util.List;

 /**

  * @see AttributeField for more info.

  */

 @XmlRootElement(name = RemotableAttributeField.Constants.ROOT_ELEMENT_NAME)

 @XmlAccessorType(XmlAccessType.NONE)

 @XmlType(name = RemotableAttributeField.Constants.TYPE_NAME, propOrder = {

                 RemotableAttributeField.Elements.NAME,

                 RemotableAttributeField.Elements.DATA_TYPE,

                 RemotableAttributeField.Elements.SHORT_LABEL,

                 RemotableAttributeField.Elements.LONG_LABEL,

                 RemotableAttributeField.Elements.HELP_SUMMARY,

                 RemotableAttributeField.Elements.HELP_CONSTRAINT,

                 RemotableAttributeField.Elements.HELP_DESCRIPTION,

                 RemotableAttributeField.Elements.FORCE_UPPERCASE,

                 RemotableAttributeField.Elements.MIN_LENGTH,

                 RemotableAttributeField.Elements.MAX_LENGTH,

                 RemotableAttributeField.Elements.MIN_VALUE,

                 RemotableAttributeField.Elements.MAX_VALUE,

                 RemotableAttributeField.Elements.REGEX_CONSTRAINT,

                 RemotableAttributeField.Elements.REGEX_CONSTRAINT_MSG,

                 RemotableAttributeField.Elements.REQUIRED,

                 RemotableAttributeField.Elements.DEFAULT_VALUES,

         RemotableAttributeField.Elements.ATTRIBUTE_LOOKUP_SETTINGS,

                 RemotableAttributeField.Elements.CONTROL,

                 RemotableAttributeField.Elements.WIDGETS,

                 CoreConstants.CommonElements.FUTURE_ELEMENTS })

 public final class RemotableAttributeField extends AbstractDataTransferObject implements AttributeField {

     @XmlElement(name = Elements.NAME, required = true)

     private final String name;

     @XmlJavaTypeAdapter(DataType.Adapter.class)

     @XmlElement(name = Elements.DATA_TYPE, required = false)

     private final String dataType;

     @XmlElement(name = Elements.SHORT_LABEL, required = false)

     private final String shortLabel;

     @XmlElement(name = Elements.LONG_LABEL, required = false)

     private final String longLabel;

     @XmlElement(name = Elements.HELP_SUMMARY, required = false)

     private final String helpSummary;

     @XmlElement(name = Elements.HELP_CONSTRAINT, required = false)

     private final String helpConstraint;

     @XmlElement(name = Elements.HELP_DESCRIPTION, required = false)

     private final String helpDescription;

     @XmlElement(name = Elements.FORCE_UPPERCASE, required = false)

     private final boolean forceUpperCase;

     @XmlElement(name = Elements.MIN_LENGTH, required = false)

     private final Integer minLength;

     @XmlElement(name = Elements.MAX_LENGTH, required = false)

     private final Integer maxLength;

     @XmlElement(name = Elements.MIN_VALUE, required = false)

     private final Double minValue;

     @XmlElement(name = Elements.MAX_VALUE, required = false)

     private final Double maxValue;

     @XmlElement(name = Elements.REGEX_CONSTRAINT, required = false)

     private final String regexConstraint;

     @XmlElement(name = Elements.REGEX_CONSTRAINT_MSG, required = false)

     private final String regexContraintMsg;

     @XmlElement(name = Elements.REQUIRED, required = false)

     private final boolean required;

     @XmlElementWrapper(name = Elements.DEFAULT_VALUES, required = false)

     @XmlElement(name = Elements.DEFAULT_VALUE, required = false)

     private final Collection<String> defaultValues;

     @XmlElement(name = Elements.ATTRIBUTE_LOOKUP_SETTINGS, required = false)

     private final RemotableAttributeLookupSettings attributeLookupSettings;

     @XmlElements(value = {

         @XmlElement(name = RemotableCheckboxGroup.Constants.ROOT_ELEMENT_NAME, type = RemotableCheckboxGroup.class, required = false),

         @XmlElement(name = RemotableHiddenInput.Constants.ROOT_ELEMENT_NAME, type = RemotableHiddenInput.class, required = false),

         @XmlElement(name = RemotablePasswordInput.Constants.ROOT_ELEMENT_NAME, type = RemotablePasswordInput.class, required = false),

         @XmlElement(name = RemotableRadioButtonGroup.Constants.ROOT_ELEMENT_NAME, type = RemotableRadioButtonGroup.class, required = false),

         @XmlElement(name = RemotableSelect.Constants.ROOT_ELEMENT_NAME, type = RemotableSelect.class, required = false),

         @XmlElement(name = RemotableTextarea.Constants.ROOT_ELEMENT_NAME, type = RemotableTextarea.class, required = false),

         @XmlElement(name = RemotableTextInput.Constants.ROOT_ELEMENT_NAME, type = RemotableTextInput.class, required = false)

     })

     private final RemotableAbstractControl control;

     @XmlElementWrapper(name = Elements.WIDGETS, required = false)

     @XmlElements(value = {

         @XmlElement(name = RemotableDatepicker.Constants.ROOT_ELEMENT_NAME, type = RemotableDatepicker.class, required = false),

         @XmlElement(name = RemotableQuickFinder.Constants.ROOT_ELEMENT_NAME, type = RemotableQuickFinder.class, required = false),

         @XmlElement(name = RemotableTextExpand.Constants.ROOT_ELEMENT_NAME, type = RemotableTextExpand.class, required = false)

     })

     private final Collection<? extends RemotableAbstractWidget> widgets;

     @SuppressWarnings("unused")

     @XmlAnyElement

     private final Collection<Element> _futureElements = null;

     /**

      * Should only be invoked by JAXB.

      */

     @SuppressWarnings("unused")

     private RemotableAttributeField() {

         this.name = null;

         this.dataType = null;

         this.shortLabel = null;

         this.longLabel = null;

         this.helpSummary = null;

         this.helpConstraint = null;

         this.helpDescription = null;

         this.forceUpperCase = false;

         this.minLength = null;

         this.maxLength = null;

         this.minValue = null;

         this.maxValue = null;

         this.regexConstraint = null;

         this.regexContraintMsg = null;

         this.required = false;

         this.defaultValues = null;

         this.attributeLookupSettings = null;

         this.control = null;

         this.widgets = null;

     }

     private RemotableAttributeField(Builder b) {

         this.name = b.name;

         if (b.dataType == null) {

             this.dataType = null;

         } else {

             this.dataType = b.dataType.name();

         }

         this.shortLabel = b.shortLabel;

         this.longLabel = b.longLabel;

         this.helpSummary = b.helpSummary;

         this.helpConstraint = b.helpConstraint;

         this.helpDescription = b.helpDescription;

         this.forceUpperCase = b.forceUpperCase;

         this.minLength = b.minLength;

         this.maxLength = b.maxLength;

         this.minValue = b.minValue;

         this.maxValue = b.maxValue;

         this.regexConstraint = b.regexConstraint;

         this.regexContraintMsg = b.regexContraintMsg;

         this.required = b.required;

         if (b.defaultValues == null) {

             this.defaultValues = Collections.emptyList();

         } else {

             List<String> defaultValuesCopy = new ArrayList<String>(b.defaultValues);

             this.defaultValues = Collections.unmodifiableList(defaultValuesCopy);

         }

         if (b.attributeLookupSettings == null) {

             this.attributeLookupSettings = null;

         } else {

             this.attributeLookupSettings = b.attributeLookupSettings.build();

         }

         if (b.control == null) {

             this.control = null;

         } else {

             this.control = b.control.build();

         }

         final List<RemotableAbstractWidget> temp = new ArrayList<RemotableAbstractWidget>();

         if (b.widgets != null) {

             for (RemotableAbstractWidget.Builder attr : b.widgets) {

                 temp.add(attr.build());

             }

         }

         this.widgets = Collections.unmodifiableList(temp);

     }

     @Override

     public String getName() {

         return name;

     }

     @Override

     public DataType getDataType() {

         if (dataType == null) {

             return null;

         }

         return DataType.valueOf(dataType);

     }

     @Override

     public String getShortLabel() {

         return shortLabel;

     }

     @Override

     public String getLongLabel() {

         return longLabel;

     }

     @Override

     public String getHelpSummary() {

         return helpSummary;

     }

     @Override

     public String getHelpConstraint() {

         return helpConstraint;

     }

     @Override

     public String getHelpDescription() {

         return helpDescription;

     }

     @Override

     public boolean isForceUpperCase() {

         return forceUpperCase;

     }

     @Override

     public Integer getMinLength() {

         return minLength;

     }

     @Override

     public Integer getMaxLength() {

         return maxLength;

     }

     @Override

     public Double getMinValue() {

         return minValue;

     }

     @Override

     public Double getMaxValue() {

         return maxValue;

     }

     @Override

     public String getRegexConstraint() {

         return regexConstraint;

     }

     @Override

     public String getRegexContraintMsg() {

         return regexContraintMsg;

     }

     @Override

     public boolean isRequired() {

         return required;

     }

     @Override

     public Collection<String> getDefaultValues() {

         return defaultValues;

     }

     @Override

     public Control getControl() {

         return control;

     }

     @Override

     public Collection<? extends RemotableAbstractWidget> getWidgets() {

         return widgets;

     }

     @Override

     public AttributeLookupSettings getAttributeLookupSettings() {

         return attributeLookupSettings;

     }

     /**

      * Utility method to search a collection of attribute fields and returns

      * a field for a give attribute name.

      *

      * @param attributeName the name of the attribute to search for.  Cannot be blank or null.

      * @param fields cannot be null.

      *

      * @return the attribute field or null if not found.

      */

     public static RemotableAttributeField findAttribute(String attributeName, Collection<RemotableAttributeField> fields) {

         if (StringUtils.isBlank(attributeName)) {

             throw new IllegalArgumentException("attributeName is blank");

         }

         if (fields == null) {

             throw new IllegalArgumentException("errors is null");

         }

         for (RemotableAttributeField field : fields) {

             if (attributeName.equals(field.getName())) {

                 return field;

             }

         }

         return null;

     }

     public static final class Builder implements AttributeField, ModelBuilder {

         private String name;

         private DataType dataType;

         private String shortLabel;

         private String longLabel;

         private String helpSummary;

         private String helpConstraint;

         private String helpDescription;

         private boolean forceUpperCase;

         private Integer minLength;

         private Integer maxLength;

         private Double minValue;

         private Double maxValue;

         private String regexConstraint;

         private String regexContraintMsg;

         private boolean required;

         private Collection<String> defaultValues = new ArrayList<String>();

         private RemotableAttributeLookupSettings.Builder attributeLookupSettings;

         private RemotableAbstractControl.Builder control;

         private Collection<RemotableAbstractWidget.Builder> widgets = new ArrayList<RemotableAbstractWidget.Builder>();

         private Builder(String name) {

             setName(name);

         }

         public static Builder create(String name) {

             return new Builder(name);

         }

         public static Builder create(AttributeField field) {

             if (field == null) {

                 throw new IllegalArgumentException("field was null");

             }

             Builder b = new Builder(field.getName());

             b.setDataType(field.getDataType());

             b.setShortLabel(field.getShortLabel());

             b.setLongLabel(field.getLongLabel());

             b.setHelpSummary(field.getHelpSummary());

             b.setHelpConstraint(field.getHelpConstraint());

             b.setHelpDescription(field.getHelpDescription());

             b.setForceUpperCase(field.isForceUpperCase());

             b.setMinLength(field.getMinLength());

             b.setMaxLength(field.getMaxLength());

             b.setMinValue(field.getMinValue());

             b.setMaxValue(field.getMaxValue());

             b.setRegexConstraint(field.getRegexConstraint());

             b.setRegexContraintMsg(field.getRegexContraintMsg());

             b.setRequired(field.isRequired());

             b.setDefaultValues(field.getDefaultValues());

             if (field.getAttributeLookupSettings() != null) {

                 b.setAttributeLookupSettings(RemotableAttributeLookupSettings.Builder.create(

                         field.getAttributeLookupSettings()));

             }

             if (field.getControl() != null) {

                 b.setControl(ControlCopy.toBuilder(field.getControl()));

             }

             final List<RemotableAbstractWidget.Builder> temp = new ArrayList<RemotableAbstractWidget.Builder>();

             if (field.getWidgets() != null) {

                 for (Widget w : field.getWidgets()) {

                     temp.add(WidgetCopy.toBuilder(w));

                 }

             }

             b.setWidgets(temp);

             return b;

         }

         @Override

         public String getName() {

             return name;

         }

         public void setName(String name) {

             if (StringUtils.isBlank(name)) {

                 throw new IllegalArgumentException("name is blank");

             }

             this.name = name;

         }

         @Override

         public DataType getDataType() {

             return dataType;

         }

         public void setDataType(DataType dataType) {

             this.dataType = dataType;

         }

         @Override

         public String getShortLabel() {

             return shortLabel;

         }

         public void setShortLabel(String shortLabel) {

             this.shortLabel = shortLabel;

         }

         @Override

         public String getLongLabel() {

             return longLabel;

         }

         public void setLongLabel(String longLabel) {

             this.longLabel = longLabel;

         }

         @Override

         public String getHelpSummary() {

             return helpSummary;

         }

         public void setHelpSummary(String helpSummary) {

             this.helpSummary = helpSummary;

         }

         @Override

         public String getHelpConstraint() {

             return helpConstraint;

         }

         public void setHelpConstraint(String helpConstraint) {

             this.helpConstraint = helpConstraint;

         }

         @Override

         public String getHelpDescription() {

             return helpDescription;

         }

         public void setHelpDescription(String helpDescription) {

             this.helpDescription = helpDescription;

         }

         @Override

         public boolean isForceUpperCase() {

             return forceUpperCase;

         }

         public void setForceUpperCase(boolean forceUpperCase) {

             this.forceUpperCase = forceUpperCase;

         }

         @Override

         public Integer getMinLength() {

             return minLength;

         }

         public void setMinLength(Integer minLength) {

             if (minLength != null && minLength < 1) {

                 throw new IllegalArgumentException("minLength was < 1");

             }

             this.minLength = minLength;

         }

         @Override

         public Integer getMaxLength() {

             return maxLength;

         }

         public void setMaxLength(Integer maxLength) {

             if (maxLength != null && maxLength < 1) {

                 throw new IllegalArgumentException("maxLength was < 1");

             }

             this.maxLength = maxLength;

         }

         @Override

         public Double getMinValue() {

             return minValue;

         }

         public void setMinValue(Double minValue) {

             this.minValue = minValue;

         }

         @Override

         public Double getMaxValue() {

             return maxValue;

         }

         public void setMaxValue(Double maxValue) {

             this.maxValue = maxValue;

         }

         @Override

         public String getRegexConstraint() {

             return regexConstraint;

         }

         public void setRegexConstraint(String regexConstraint) {

             this.regexConstraint = regexConstraint;

         }

         @Override

         public String getRegexContraintMsg() {

             return regexContraintMsg;

         }

         public void setRegexContraintMsg(String regexContraintMsg) {

             this.regexContraintMsg = regexContraintMsg;

         }

         @Override

         public boolean isRequired() {

             return required;

         }

         public void setRequired(boolean required) {

             this.required = required;

         }

         @Override

         public Collection<String> getDefaultValues() {

             return defaultValues;

         }

         public void setDefaultValues(Collection<String> defaultValues) {

             this.defaultValues = defaultValues;

         }

         @Override

         public RemotableAttributeLookupSettings.Builder getAttributeLookupSettings() {

             return attributeLookupSettings;

         }

         public void setAttributeLookupSettings(RemotableAttributeLookupSettings.Builder attributeLookupSettings) {

             this.attributeLookupSettings = attributeLookupSettings;

         }

         @Override

         public RemotableAbstractControl.Builder getControl() {

             return control;

         }

         public void setControl(RemotableAbstractControl.Builder control) {

             this.control = control;

         }

         @Override

         public Collection<RemotableAbstractWidget.Builder> getWidgets() {

             return widgets;

         }

         public void setWidgets(Collection<RemotableAbstractWidget.Builder> widgets) {

             this.widgets = widgets;

         }

         @Override

         public RemotableAttributeField build() {

             return new RemotableAttributeField(this);

         }

     }

     /**

      * Defines some internal constants used on this class.

      */

     static final class Constants {

         static final String TYPE_NAME = "AttributeFieldType";

         final static String ROOT_ELEMENT_NAME = "attributeField";

     }

     static final class Elements {

         static final String NAME = "name";

         static final String DATA_TYPE = "dataType";

         static final String SHORT_LABEL = "shortLabel";

         static final String LONG_LABEL = "longLabel";

         static final String HELP_SUMMARY = "helpSummary";

         static final String HELP_CONSTRAINT = "helpConstraint";

         static final String HELP_DESCRIPTION = "helpDescription";

         static final String FORCE_UPPERCASE = "forceUpperCase";

         static final String MIN_LENGTH = "minLength";

         static final String MAX_LENGTH = "maxLength";

         static final String MIN_VALUE = "minValue";

         static final String MAX_VALUE = "maxValue";

         static final String REGEX_CONSTRAINT = "regexConstraint";

         static final String REGEX_CONSTRAINT_MSG = "regexContraintMsg";

         static final String REQUIRED = "required";

         static final String DEFAULT_VALUES = "defaultValues";

         static final String DEFAULT_VALUE = "defaultValue";

         static final String ATTRIBUTE_LOOKUP_SETTINGS = "attributeLookupSettings";

         static final String CONTROL = "control";

         static final String WIDGETS = "widgets";

     }

 }