/**
    *    Copyright 2009-2019 the original author or authors.
    *
    *    Licensed under the Apache 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.apache.org/licenses/LICENSE-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.apache.ibatis.mapping;
  
  import java.sql.ResultSet;
  
  import org.apache.ibatis.session.Configuration;
  import org.apache.ibatis.type.JdbcType;
  import org.apache.ibatis.type.TypeHandler;
  import org.apache.ibatis.type.TypeHandlerRegistry;
  
  /**
   * @author Clinton Begin
   */
  public class ParameterMapping {
  
    private Configuration configuration;
  
    private String property;
    private ParameterMode mode;
    private Class<?> javaType = Object.class;
    private JdbcType jdbcType;
    private Integer numericScale;
    private TypeHandler<?> typeHandler;
    private String resultMapId;
    private String jdbcTypeName;
    private String expression;
  
    private ParameterMapping() {
    }
  
    public static class Builder {
      private ParameterMappingParameterMapping">ParameterMapping parameterMapping = new ParameterMapping();
  
      public Builder(Configuration configuration, String property, TypeHandler<?> typeHandler) {
        parameterMapping.configuration = configuration;
        parameterMapping.property = property;
        parameterMapping.typeHandler = typeHandler;
        parameterMapping.mode = ParameterMode.IN;
      }
  
      public Builder(Configuration configuration, String property, Class<?> javaType) {
        parameterMapping.configuration = configuration;
        parameterMapping.property = property;
        parameterMapping.javaType = javaType;
        parameterMapping.mode = ParameterMode.IN;
      }
  
      public Builder mode(ParameterMode mode) {
        parameterMapping.mode = mode;
        return this;
      }
  
      public Builder javaType(Class<?> javaType) {
        parameterMapping.javaType = javaType;
        return this;
      }
  
      public Builder jdbcType(JdbcType jdbcType) {
        parameterMapping.jdbcType = jdbcType;
        return this;
      }
  
      public Builder numericScale(Integer numericScale) {
        parameterMapping.numericScale = numericScale;
        return this;
      }
  
      public Builder resultMapId(String resultMapId) {
        parameterMapping.resultMapId = resultMapId;
        return this;
      }
  
      public Builder typeHandler(TypeHandler<?> typeHandler) {
        parameterMapping.typeHandler = typeHandler;
        return this;
      }
  
      public Builder jdbcTypeName(String jdbcTypeName) {
        parameterMapping.jdbcTypeName = jdbcTypeName;
        return this;
      }
  
      public Builder expression(String expression) {
        parameterMapping.expression = expression;
        return this;
     }
 
     public ParameterMapping build() {
       resolveTypeHandler();
       validate();
       return parameterMapping;
     }
 
     private void validate() {
       if (ResultSet.class.equals(parameterMapping.javaType)) {
         if (parameterMapping.resultMapId == null) {
           throw new IllegalStateException("Missing resultmap in property '"
               + parameterMapping.property + "'.  "
               + "Parameters of type java.sql.ResultSet require a resultmap.");
         }
       } else {
         if (parameterMapping.typeHandler == null) {
           throw new IllegalStateException("Type handler was null on parameter mapping for property '"
             + parameterMapping.property + "'. It was either not specified and/or could not be found for the javaType ("
             + parameterMapping.javaType.getName() + ") : jdbcType (" + parameterMapping.jdbcType + ") combination.");
         }
       }
     }
 
     private void resolveTypeHandler() {
       if (parameterMapping.typeHandler == null && parameterMapping.javaType != null) {
         Configuration configuration = parameterMapping.configuration;
         TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
         parameterMapping.typeHandler = typeHandlerRegistry.getTypeHandler(parameterMapping.javaType, parameterMapping.jdbcType);
       }
     }
 
   }
 
   public String getProperty() {
     return property;
   }
 
   /**
    * Used for handling output of callable statements.
    * @return
    */
   public ParameterMode getMode() {
     return mode;
   }
 
   /**
    * Used for handling output of callable statements.
    * @return
    */
   public Class<?> getJavaType() {
     return javaType;
   }
 
   /**
    * Used in the UnknownTypeHandler in case there is no handler for the property type.
    * @return
    */
   public JdbcType getJdbcType() {
     return jdbcType;
   }
 
   /**
    * Used for handling output of callable statements.
    * @return
    */
   public Integer getNumericScale() {
     return numericScale;
   }
 
   /**
    * Used when setting parameters to the PreparedStatement.
    * @return
    */
   public TypeHandler<?> getTypeHandler() {
     return typeHandler;
   }
 
   /**
    * Used for handling output of callable statements.
    * @return
    */
   public String getResultMapId() {
     return resultMapId;
   }
 
   /**
    * Used for handling output of callable statements.
    * @return
    */
   public String getJdbcTypeName() {
     return jdbcTypeName;
   }
 
   /**
    * Not used
    * @return
    */
   public String getExpression() {
     return expression;
   }
 
   @Override
   public String toString() {
     final StringBuilder sb = new StringBuilder("ParameterMapping{");
     //sb.append("configuration=").append(configuration); // configuration doesn't have a useful .toString()
     sb.append("property='").append(property).append('\'');
     sb.append(", mode=").append(mode);
     sb.append(", javaType=").append(javaType);
     sb.append(", jdbcType=").append(jdbcType);
     sb.append(", numericScale=").append(numericScale);
     //sb.append(", typeHandler=").append(typeHandler); // typeHandler also doesn't have a useful .toString()
     sb.append(", resultMapId='").append(resultMapId).append('\'');
     sb.append(", jdbcTypeName='").append(jdbcTypeName).append('\'');
     sb.append(", expression='").append(expression).append('\'');
     sb.append('}');
     return sb.toString();
   }
 }