package com.ibatis.sqlmap.engine.builder.xml;

import com.ibatis.common.resources.Resources;
import com.ibatis.common.xml.Nodelet;
import com.ibatis.common.xml.NodeletParser;
import com.ibatis.common.xml.NodeletUtils;

import com.ibatis.common.beans.ClassInfo;
import com.ibatis.sqlmap.client.SqlMapClient;
import com.ibatis.sqlmap.client.SqlMapException;
import com.ibatis.sqlmap.client.extensions.TypeHandlerCallback;
import com.ibatis.sqlmap.engine.accessplan.AccessPlanFactory;
import com.ibatis.sqlmap.engine.cache.CacheModel;
import com.ibatis.sqlmap.engine.cache.fifo.FifoCacheController;
import com.ibatis.sqlmap.engine.cache.lru.LruCacheController;
import com.ibatis.sqlmap.engine.cache.memory.MemoryCacheController;
import com.ibatis.sqlmap.engine.datasource.DataSourceFactory;
import com.ibatis.sqlmap.engine.datasource.DbcpDataSourceFactory;
import com.ibatis.sqlmap.engine.datasource.JndiDataSourceFactory;
import com.ibatis.sqlmap.engine.datasource.SimpleDataSourceFactory;
import com.ibatis.sqlmap.engine.impl.SqlMapClientImpl;
import com.ibatis.sqlmap.engine.impl.SqlMapExecutorDelegate;
import com.ibatis.sqlmap.engine.mapping.result.ResultObjectFactory;
import com.ibatis.sqlmap.engine.mapping.statement.MappedStatement;
import com.ibatis.sqlmap.engine.transaction.TransactionConfig;
import com.ibatis.sqlmap.engine.transaction.TransactionManager;
import com.ibatis.sqlmap.engine.transaction.external.ExternalTransactionConfig;
import com.ibatis.sqlmap.engine.transaction.jdbc.JdbcTransactionConfig;
import com.ibatis.sqlmap.engine.transaction.jta.JtaTransactionConfig;
import com.ibatis.sqlmap.engine.type.*;

import org.w3c.dom.Node;

import java.io.InputStream;
import java.io.Reader;
import java.util.Iterator;
import java.util.Properties;

public class SqlMapConfigParser extends BaseParser {

  protected final NodeletParser parser = new NodeletParser();
  private boolean usingStreams;

  public SqlMapConfigParser() {
    this(null, null);
  }

  public SqlMapConfigParser(XmlConverter sqlMapConfigConv, XmlConverter sqlMapConv) {
    super(new Variables());
    parser.setValidation(true);
    parser.setEntityResolver(new SqlMapClasspathEntityResolver());

    vars.sqlMapConfigConv = sqlMapConfigConv;
    vars.sqlMapConv = sqlMapConv;

    vars.delegate = new SqlMapExecutorDelegate();
    vars.typeHandlerFactory = vars.delegate.getTypeHandlerFactory();
    vars.client = new SqlMapClientImpl(vars.delegate);

    registerDefaultTypeAliases();

    addSqlMapConfigNodelets();
    addGlobalPropNodelets();
    addSettingsNodelets();
    addTypeAliasNodelets();
    addTypeHandlerNodelets();
    addTransactionManagerNodelets();
    addSqlMapNodelets();
    addResultObjectFactoryNodelets();

  }

  public SqlMapClient parse(Reader reader, Properties props) {
    vars.properties = props;
    return parse(reader);
  }

  public SqlMapClient parse(Reader reader) {
    try {
      if (vars.sqlMapConfigConv != null) {
        reader = vars.sqlMapConfigConv.convertXml(reader);
      }

      usingStreams = false;
      
      parser.parse(reader);
      return vars.client;
    } catch (Exception e) {
      throw new RuntimeException("Error occurred.  Cause: " + e, e);
    }
  }

  public SqlMapClient parse(InputStream inputStream, Properties props) {
    vars.properties = props;
    return parse(inputStream);
  }

  public SqlMapClient parse(InputStream inputStream) {
    try {
      if (vars.sqlMapConfigConv != null) {
        inputStream = vars.sqlMapConfigConv.convertXml(inputStream);
      }
      
      usingStreams = true;

      parser.parse(inputStream);
      return vars.client;
    } catch (Exception e) {
      throw new RuntimeException("Error occurred.  Cause: " + e, e);
    }
  }

  private void addSqlMapConfigNodelets() {
    parser.addNodelet("/sqlMapConfig/end()", new Nodelet() {
      public void process(Node node) throws Exception {
        Iterator cacheNames = vars.client.getDelegate().getCacheModelNames();

        while (cacheNames.hasNext()) {
          String cacheName = (String) cacheNames.next();
          CacheModel cacheModel = vars.client.getDelegate().getCacheModel(cacheName);
          Iterator statementNames = cacheModel.getFlushTriggerStatementNames();
          while (statementNames.hasNext()) {
            String statementName = (String) statementNames.next();
            MappedStatement statement = vars.client.getDelegate().getMappedStatement(statementName);
            if (statement != null) {
              statement.addExecuteListener(cacheModel);
            } else {
              throw new RuntimeException("Could not find statement named '" + statementName + "' for use as a flush trigger for the cache model named '" + cacheName + "'.");
            }
          }
        }
      }
    });
  }

  private void addGlobalPropNodelets() {
    parser.addNodelet("/sqlMapConfig/properties", new Nodelet() {
      public void process(Node node) throws Exception {
        vars.errorCtx.setActivity("loading global properties");

        Properties attributes = NodeletUtils.parseAttributes(node,vars.properties);
        String resource = attributes.getProperty("resource");
        String url = attributes.getProperty("url");

        try {
          Properties props = null;
          if (resource != null) {
            vars.errorCtx.setResource(resource);
            props = Resources.getResourceAsProperties(resource);
          } else if (url != null) {
            vars.errorCtx.setResource(url);
            props = Resources.getUrlAsProperties(url);
          } else {
            throw new RuntimeException("The " + "properties" + " element requires either a resource or a url attribute.");
          }

          if (vars.properties == null) {
            vars.properties = props;
          } else {
            props.putAll(vars.properties);
            vars.properties = props;
          }
        } catch (Exception e) {
          throw new RuntimeException("Error loading properties.  Cause: " + e);
        }
      }
    });
  }

  private void addSettingsNodelets() {
    parser.addNodelet("/sqlMapConfig/settings", new Nodelet() {
      public void process(Node node) throws Exception {
        vars.errorCtx.setActivity("loading settings properties");

        Properties attributes = NodeletUtils.parseAttributes(node, vars.properties);

        String classInfoCacheEnabledAttr = attributes.getProperty("classInfoCacheEnabled");
        boolean classInfoCacheEnabled = (classInfoCacheEnabledAttr == null || "true".equals(classInfoCacheEnabledAttr));
        ClassInfo.setCacheEnabled(classInfoCacheEnabled);

        String lazyLoadingEnabledAttr = attributes.getProperty("lazyLoadingEnabled");
        boolean lazyLoadingEnabled = (lazyLoadingEnabledAttr == null || "true".equals(lazyLoadingEnabledAttr));
        vars.client.getDelegate().setLazyLoadingEnabled(lazyLoadingEnabled);

        String statementCachingEnabledAttr = attributes.getProperty("statementCachingEnabled");
        boolean statementCachingEnabled = (statementCachingEnabledAttr == null || "true".equals(statementCachingEnabledAttr));
        vars.client.getDelegate().setStatementCacheEnabled(statementCachingEnabled);

        String cacheModelsEnabledAttr = attributes.getProperty("cacheModelsEnabled");
        boolean cacheModelsEnabled = (cacheModelsEnabledAttr == null || "true".equals(cacheModelsEnabledAttr));
        vars.client.getDelegate().setCacheModelsEnabled(cacheModelsEnabled);

        String enhancementEnabledAttr = attributes.getProperty("enhancementEnabled");
        boolean enhancementEnabled = (enhancementEnabledAttr == null || "true".equals(enhancementEnabledAttr));
        try {
          enhancementEnabled = enhancementEnabled && Resources.classForName("net.sf.cglib.proxy.InvocationHandler") != null;
        } catch (ClassNotFoundException e) {
          enhancementEnabled = false;
        }
        vars.client.getDelegate().setEnhancementEnabled(enhancementEnabled);

        String useStatementNamespacesAttr = attributes.getProperty("useStatementNamespaces");
        vars.useStatementNamespaces = ("true".equals(useStatementNamespacesAttr));

        String maxTransactions = attributes.getProperty("maxTransactions");
        if (maxTransactions != null && Integer.parseInt(maxTransactions) > 0) {
          vars.client.getDelegate().setMaxTransactions(Integer.parseInt(maxTransactions));
        }

        String maxRequests = attributes.getProperty("maxRequests");
        if (maxRequests != null && Integer.parseInt(maxRequests) > 0) {
          vars.client.getDelegate().setMaxRequests(Integer.parseInt(maxRequests));
        }

        String maxSessions = attributes.getProperty("maxSessions");
        if (maxSessions != null && Integer.parseInt(maxSessions) > 0) {
          vars.client.getDelegate().setMaxSessions(Integer.parseInt(maxSessions));
        }

        AccessPlanFactory.setBytecodeEnhancementEnabled(vars.client.getDelegate().isEnhancementEnabled());
        
        String defaultStatementTimeout = attributes.getProperty("defaultStatementTimeout");
        if (defaultStatementTimeout != null) {
          try {
            Integer defaultTimeout = Integer.valueOf(defaultStatementTimeout);
            vars.defaultStatementTimeout = defaultTimeout;
          } catch (NumberFormatException e) {
            throw new SqlMapException("Specified defaultStatementTimeout is not a valid integer");
          }
        }
      }
    });
  }

  private void addTypeAliasNodelets() {