/**
    *    Copyright 2009-2015 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.session.defaults;
  
  import java.sql.Connection;
  import java.sql.SQLException;
  import java.util.Collection;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.ibatis.binding.BindingException;
  import org.apache.ibatis.exceptions.ExceptionFactory;
  import org.apache.ibatis.exceptions.TooManyResultsException;
  import org.apache.ibatis.executor.BatchResult;
  import org.apache.ibatis.executor.ErrorContext;
  import org.apache.ibatis.executor.Executor;
  import org.apache.ibatis.executor.result.DefaultMapResultHandler;
  import org.apache.ibatis.executor.result.DefaultResultContext;
  import org.apache.ibatis.mapping.MappedStatement;
  import org.apache.ibatis.session.Configuration;
  import org.apache.ibatis.session.ResultHandler;
  import org.apache.ibatis.session.RowBounds;
  import org.apache.ibatis.session.SqlSession;
  
  /**
   *
   * The default implementation for {@link SqlSession}.
   * Note that this class is not Thread-Safe.
   *
   * @author Clinton Begin
   */
  public class DefaultSqlSession implements SqlSession {
  
    private Configuration configuration;
    private Executor executor;
  
    private boolean autoCommit;
    private boolean dirty;
  
    public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
      this.configuration = configuration;
      this.executor = executor;
      this.dirty = false;
      this.autoCommit = autoCommit;
    }
  
    public DefaultSqlSession(Configuration configuration, Executor executor) {
      this(configuration, executor, false);
    }
  
    @Override
    public <T> T selectOne(String statement) {
      return this.<T>selectOne(statement, null);
    }
  
    @Override
    public <T> T selectOne(String statement, Object parameter) {
      // Popular vote was to return null on 0 results and throw exception on too many.
      List<T> list = this.<T>selectList(statement, parameter);
      if (list.size() == 1) {
        return list.get(0);
      } else if (list.size() > 1) {
        throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
      } else {
        return null;
      }
    }
  
    @Override
    public <K, V> Map<K, V> selectMap(String statement, String mapKey) {
      return this.selectMap(statement, null, mapKey, RowBounds.DEFAULT);
    }
  
    @Override
    public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey) {
      return this.selectMap(statement, parameter, mapKey, RowBounds.DEFAULT);
    }
  
    @Override
    public <K, V> Map<K, V> selectMap(String statement, Object parameter, String mapKey, RowBounds rowBounds) {
      final List<? extends V> list = selectList(statement, parameter, rowBounds);
      final DefaultMapResultHandler<K, V> mapResultHandler = new DefaultMapResultHandler<K, V>(mapKey,
          configuration.getObjectFactory(), configuration.getObjectWrapperFactory(), configuration.getReflectorFactory());
      final DefaultResultContext<V> context = new DefaultResultContext<V>();
      for (V o : list) {
       context.nextResultObject(o);
       mapResultHandler.handleResult(context);
     }
     return mapResultHandler.getMappedResults();
   }
 
   @Override
   public <E> List<E> selectList(String statement) {
     return this.selectList(statement, null);
   }
 
   @Override
   public <E> List<E> selectList(String statement, Object parameter) {
     return this.selectList(statement, parameter, RowBounds.DEFAULT);
   }
 
   @Override
   public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
     try {
       MappedStatement ms = configuration.getMappedStatement(statement);
       return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
     } catch (Exception e) {
       throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
     } finally {
       ErrorContext.instance().reset();
     }
   }
 
   @Override
   public void select(String statement, Object parameter, ResultHandler handler) {
     select(statement, parameter, RowBounds.DEFAULT, handler);
   }
 
   @Override
   public void select(String statement, ResultHandler handler) {
     select(statement, null, RowBounds.DEFAULT, handler);
   }
 
   @Override
   public void select(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
     try {
       MappedStatement ms = configuration.getMappedStatement(statement);
       executor.query(ms, wrapCollection(parameter), rowBounds, handler);
     } catch (Exception e) {
       throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
     } finally {
       ErrorContext.instance().reset();
     }
   }
 
   @Override
   public int insert(String statement) {
     return insert(statement, null);
   }
 
   @Override
   public int insert(String statement, Object parameter) {
     return update(statement, parameter);
   }
 
   @Override
   public int update(String statement) {
     return update(statement, null);
   }
 
   @Override
   public int update(String statement, Object parameter) {
     try {
       dirty = true;
       MappedStatement ms = configuration.getMappedStatement(statement);
       return executor.update(ms, wrapCollection(parameter));
     } catch (Exception e) {
       throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
     } finally {
       ErrorContext.instance().reset();
     }
   }
 
   @Override
   public int delete(String statement) {
     return update(statement, null);
   }
 
   @Override
   public int delete(String statement, Object parameter) {
     return update(statement, parameter);
   }
 
   @Override
   public void commit() {
     commit(false);
   }
 
   @Override
   public void commit(boolean force) {
     try {
       executor.commit(isCommitOrRollbackRequired(force));
       dirty = false;
     } catch (Exception e) {
       throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
     } finally {
       ErrorContext.instance().reset();
     }
   }
 
   @Override
   public void rollback() {
     rollback(false);
   }
 
   @Override
   public void rollback(boolean force) {
     try {
       executor.rollback(isCommitOrRollbackRequired(force));
       dirty = false;
     } catch (Exception e) {
       throw ExceptionFactory.wrapException("Error rolling back transaction.  Cause: " + e, e);
     } finally {
       ErrorContext.instance().reset();
     }
   }
 
   @Override
   public List<BatchResult> flushStatements() {
     try {
       return executor.flushStatements();
     } catch (Exception e) {
       throw ExceptionFactory.wrapException("Error flushing statements.  Cause: " + e, e);
     } finally {
       ErrorContext.instance().reset();
     }
   }
 
   @Override
   public void close() {
     try {
       executor.close(isCommitOrRollbackRequired(false));
       dirty = false;
     } finally {
       ErrorContext.instance().reset();
     }
   }
 
   @Override
   public Configuration getConfiguration() {
     return configuration;
   }
 
   @Override
   public <T> T getMapper(Class<T> type) {
     return configuration.<T>getMapper(type, this);
   }
 
   @Override
   public Connection getConnection() {
     try {
       return executor.getTransaction().getConnection();
     } catch (SQLException e) {
       throw ExceptionFactory.wrapException("Error getting a new connection.  Cause: " + e, e);
     }
   }
 
   @Override
   public void clearCache() {
     executor.clearLocalCache();
   }
 
   private boolean isCommitOrRollbackRequired(boolean force) {
     return (!autoCommit && dirty) || force;
   }
 
   private Object wrapCollection(final Object object) {
     if (object instanceof Collection) {
       StrictMap<Object> map = new StrictMap<Object>();
       map.put("collection", object);
       if (object instanceof List) {
         map.put("list", object);
       }
       return map;
     } else if (object != null && object.getClass().isArray()) {
       StrictMap<Object> map = new StrictMap<Object>();
       map.put("array", object);
       return map;
     }
     return object;
   }
 
   public static class StrictMap<V> extends HashMap<String, V> {
 
     private static final long serialVersionUID = -5741767162221585340L;
 
     @Override
     public V get(Object key) {
       if (!super.containsKey(key)) {
         throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + this.keySet());
       }
       return super.get(key);
     }
 
   }
 
 }