var DomainDaoSupport = function() {
  this.tableConfig = null;
  this.sqlTemplate = null;
  this.cacheTemplate = null;
  this.domainMap = {};
}

DomainDaoSupport.prototype.initConfig = function(domainConfig) {
  if (Utils.checkString(domainConfig)) {
    return this.initModelConfig(domainConfig);
  }

  this.doInitConfig(domainConfig);
}

DomainDaoSupport.prototype.initModelConfig = function(modelId) {
  var bearcat = Utils.getBearcat();
  var beanFactory = bearcat.getBeanFactory();
  var modelDefinition = beanFactory.getModelDefinition(modelId);
  var mid = modelDefinition.getMid();
  var table = modelDefinition.getTable();
  var fieldMap = modelDefinition.getFields();

  var primary = [];
  var fields = [];

  for (var fieldKey in fieldMap) {
    var fieldValue = fieldMap[fieldKey];
    if (fieldValue.isPrimary()) {
      var fieldType = fieldValue.getType();
      primary.push({
        name: fieldKey,
        type: fieldType
      })
    } else {
      fields.push(fieldKey);
    }
  }

  var domainConfig = {
    mid: mid,
    tableName: table,
    primary: primary,
    fields: fields
  }

  this.doInitConfig(domainConfig);
}

DomainDaoSupport.prototype.getConfig = function(domainConfig) {
  var func = domainConfig.func;
  var key = domainConfig.key;
  var primaryFields = domainConfig.primary || [];
  var fields = domainConfig.fields || [];

  if (!Utils.checkFunction(func)) {
    logger.error('domain object have no OR mapping info ' + domainConfig);
    return;
  }

  if (key) {
    var domain = this.getDomainMap(key);
    if (domain) {
      return domain;
    }
  }

  var tableConfig = new TableConfig();
  tableConfig.setFunc(func);
  tableConfig.setNormalFields(FieldUtil.buildFieldConfig(fields));
  tableConfig.setPrimaryFields(FieldUtil.buildFieldConfig(primaryFields));

  if (key) {
    this.setDomainMap(key, tableConfig);
  }

  return tableConfig;
}

SimpleDao.prototype.transaction = function(txStatus) {
    this.domainDaoSupport.transaction(txStatus);
    return this;
}

DomainDaoSupport.prototype.transaction = function(transactionStatus) {
  return this.getSqlTemplate().transaction(transactionStatus);
}

DomainDaoSupport.prototype.deleteById = function(id, cb) {
  var params = [id];

  return this.deleteByPrimaryKey(params, cb);
}

DomainDaoSupport.prototype.deleteByPrimaryKey = function(params, cb) {
  var tableConfig = this.getTableConfig();
  var primaryFields = tableConfig.getPrimaryFields();
  var tableName = tableConfig.getTableName();

  var sql = SqlBuilderUtil.buildDeleteSql(tableName, FieldUtil.fieldToNames(primaryFields));

  return this.getSqlTemplate().updateRecord(sql, params, cb);
}

DomainDaoSupport.prototype.batchAdd = function(objects, cb) {
  if (!objects || !objects.length) {
    return cb();
  }

  var tableConfig = this.getTableConfig();
  var primaryFields = tableConfig.getPrimaryFields();
  var tableName = tableConfig.getTableName();
  var fields = tableConfig.getFields(); // all fields, include primary fields

  var type = "";
  var name = "";
  var self = this;
  if (primaryFields.length === 1) {
    var primaryField = primaryFields[0];
    type = primaryField.getType();
    name = primaryField.getName();
    if (type === Constant.TYPE_LONG) {
      var len = objects.length;
      var latch = CountDownLatch.createCountDownLatch(len, function(err) {
        if (err) {
          return cb(err);
        }

        return self.doBatchAdd(objects, cb);
      });

      for (var i = 0; i < objects.length; i++) {
        (function(object) {
          var id = object[name];
          if (!id) {
            self.getSqlTemplate().allocateRecordId(tableName, function(err, id) {
              if (err) {
                return cb(err);
              }

              object[name] = id;
              latch.done();
            });
          } else {
            latch.done();
          }
        })(objects[i]);
      }
    }
  } else {
    return self.doBatchAdd(objects, cb);
  }
}

DomainDaoSupport.prototype.batchUpdate = function(objects, cb) {
  if (!objects || !objects.length) {
    return cb();
  }

  var tableConfig = this.getTableConfig();
  var primaryFields = tableConfig.getPrimaryFields();
  var tableName = tableConfig.getTableName();
  var fields = tableConfig.getFields();

  if (primaryFields.length) {
    var parasList = [];

    for (var i = 0; i < objects.length; i++) {
      var paras = [];
      for (var j = 0; j < fields.length; j++) {
        var field = fields[j];
        var name = field.getName();
        paras.push(objects[i][name]);
      }
      parasList.push(paras);
    }

    var normalColumns = FieldUtil.fieldToNames(tableConfig.getNormalFields());
    var conditionColumns = FieldUtil.fieldToNames(primaryFields);
    var sql = SqlBuilderUtil.buildUpdateSql(tableConfig.getTableName(), normalColumns, conditionColumns);
    return this.getSqlTemplate().batchUpdateRecords(sql, parasList, function(err, results) {
      if (err) {
        return cb(err);
      }

      if (results) {
        cb(null, objects);
      } else {
        cb(null, null);
      }
    });
  } else {
    logger.error('can not batchUpdate object without primary key');
    return cb();
  }
}

DomainDaoSupport.prototype.batchDelete = function(objects, cb) {
  if (!objects || !objects.length) {
    return cb();
  }

  var tableConfig = this.getTableConfig();
  var primaryFields = tableConfig.getPrimaryFields();
  var tableName = tableConfig.getTableName();
  var fields = tableConfig.getFields();

  if (primaryFields.length) {
    return this.batchDeleteByPrimaryKey(objects, cb);
  } else {
    logger.error('can not batchDelete object without primary key');
    return cb();
  }
}

DomainDaoSupport.prototype.updateColumn = function(columnName, newValue, primarysValue, cb) {
  if (!Array.isArray(primarysValue)) {
    logger.error('primarysValue must be array');
    return cb();
  }

  var tableConfig = this.getTableConfig();
  var primaryFields = tableConfig.getPrimaryFields();

  if (primaryFields.length) {
    if (primarysValue.length !== primaryFields.length) {
      logger.error("primarysValue's size must equal with the primarykey's size");
      return cb();
    }

    var params = primarysValue;
    var columns = FieldUtil.fieldToNames(primaryFields);

    return this.updateColumnValue(columnName, newValue, columns, params, cb);
  } else {
    logger.error('can not update object without primary key');
    return cb();
  }
}

DomainDaoSupport.prototype.updateColumnValue = function(columnName, newValue, conditionColumns, conditionValues, cb) {
  if (!Array.isArray(conditionColumns) || !Array.isArray(conditionValues)) {
    logger.error('conditionColumns or conditionValues must be array');
    return cb();
  }

  var tableConfig = this.getTableConfig();
  var params = [];
  params.push(newValue);

  for (var i = 0; i < conditionValues.length; i++) {
    params.push(conditionValues[i]);
  }

  var updateColumns = [];
  updateColumns.push(columnName);
  var sql = SqlBuilderUtil.buildUpdateSql(tableConfig.getTableName(), updateColumns, conditionColumns);
  return this.getSqlTemplate().updateRecord(sql, params, cb);
}

DomainDaoSupport.prototype.getList = function(sql, params, options, cb) {
  sql = SqlBuilderUtil.getSql(sql);

  var tableConfig = this.getTableConfig();
  var mid = tableConfig.getMid();
  var fields = tableConfig.getFields();
  var func = tableConfig.getFunc();
  var self = this;

  if (Utils.checkString(options)) {
    mid = options || mid;
    options = {};
  }

  if (Utils.checkFunction(options)) {
    cb = options;
    options = {};
  }

  options = options || {};
  var orderColumn = options.orderColumn;
  var isAsc = options.isAsc;
  var limit = options.limit;
  var offset = options.offset;
  var domain = options.domain;
  var mid = options.mid || mid;

  if (orderColumn) {
    sql = SqlBuilderUtil.appendOrder(sql, orderColumn, isAsc);
  }

  if (Utils.isNotNull(limit) && Utils.isNotNull(offset)) {
    sql = SqlBuilderUtil.appendLimit(sql, limit, offset);
  }

  return this.getSqlTemplate().executeQuery(sql, params, function(err, results) {
    if (err) {
      return cb(err);
    }

    var beanObjects = null;

    if (mid) {
      beanObjects = BeanBuilderUtil.buildModels(mid, results);
      return cb(null, beanObjects);
    }

    if (domain) {
      var domainConfig = self.getConfig(domain);
      beanObjects = BeanBuilderUtil.buildObjectList(results, domainConfig.getFunc(), domainConfig.getFields());
    } else {
      beanObjects = BeanBuilderUtil.buildObjectList(results, func, fields);
    }

    cb(null, beanObjects);
  });
}

DomainDaoSupport.prototype.getByPrimary = function(params, cb) {
  var tableConfig = this.getTableConfig();
  var mid = tableConfig.getMid();
  var primaryFields = tableConfig.getPrimaryFields();
  var func = tableConfig.getFunc();

  if (params.length !== primaryFields.length) {
    logger.error('parameter size must be equal with the primary fields size');
    return cb();
  }

  var fields = FieldUtil.fieldToNames(tableConfig.getFields());
  var primaryFields = FieldUtil.fieldToNames(tableConfig.getPrimaryFields());
  var sql = SqlBuilderUtil.buildSelectSql(tableConfig.getTableName(), fields, primaryFields);

  return this.getSqlTemplate().executeQuery(sql, params, function(err, results) {
    if (err) {
      return cb(err);
    }

    if (mid) {
      beanObjects = BeanBuilderUtil.buildModels(mid, results);
      return cb(null, beanObjects);
    }

    var beanObjects = BeanBuilderUtil.buildObjectList(results, func, tableConfig.getFields());
    cb(null, beanObjects);
  });
}

DomainDaoSupport.prototype.getById = function(id, cb) {
  var params = [id];

  return this.getByPrimary(params, cb);
}

DomainDaoSupport.prototype.get = function(sql, params, cb) {
  var tableConfig = this.getTableConfig();
  var mid = tableConfig.getMid();
  var func = tableConfig.getFunc();

  return this.getSqlTemplate().executeQuery(sql, params, function(err, results) {
    if (err) {
      return cb(err);
    }

    if (mid) {
      beanObjects = BeanBuilderUtil.buildModels(mid, results);
      return cb(null, beanObjects);
    }

    var beanObjects = BeanBuilderUtil.buildObjectList(results, func, tableConfig.getFields());
    cb(null, beanObjects);
  });
}

DomainDaoSupport.prototype.getCount = function(sql, params, cb) {
  return this.getSqlTemplate().queryCount(sql, params, cb);
}

DomainDaoSupport.prototype.add = function(sql, params, cb) {
  if (Utils.checkObject(sql) && Utils.checkFunction(params)) {
    return this.batchAdd([sql], params);
  }

  return this.getSqlTemplate().addRecord(sql, params, cb);
}

DomainDaoSupport.prototype.delete = function(sql, params, cb) {
  if (Utils.checkObject(sql) && Utils.checkFunction(params)) {
    return this.batchDelete([sql], params);
  }

  return this.getSqlTemplate().updateRecord(sql, params, cb);
}

DomainDaoSupport.prototype.update = function(sql, params, cb) {
  if (Utils.checkObject(sql) && Utils.checkFunction(params)) {
    return this.batchUpdate([sql], params);
  }

  return this.getSqlTemplate().updateRecord(sql, params, cb);
}

DomainDaoSupport.prototype.exists = function(sql, params, cb) {
  return this.getSqlTemplate().existRecord(sql, params, cb);
}

DomainDaoSupport.prototype.allocateRecordId = function(tableName, cb) {
  return this.getSqlTemplate().allocateRecordId(tableName, cb);
}

DomainDaoSupport.prototype.getByWhere = function(where, args, cb) {
  var tableConfig = this.getTableConfig();

  var sql = util.format(SQL_OBJECT_SELECT, tableConfig.getTableName(), where);

  return this.get(sql, args, cb);
}

DomainDaoSupport.prototype.getListByWhere = function(where, args, options, cb) {
  var tableConfig = this.getTableConfig();
  var mid = tableConfig.getMid();

  var sql = util.format(SQL_SELECT, tableConfig.getTableName(), where);

  if (Utils.checkString(options)) {
    mid = options || mid;
    options = {};
  }

  if (Utils.checkFunction(options)) {
    cb = options;
    options = {};
  }

  options = options || {};
  var orderColumn = options.orderColumn;
  var isAsc = options.isAsc;
  var limit = options.limit;
  var offset = options.offset;
  var domain = options.domain;
  var mid = options.mid || mid;

  var opt = {};

  if (orderColumn) {
    sql = SqlBuilderUtil.appendOrder(sql, orderColumn, isAsc);
  }

  if (Utils.isNotNull(limit) && Utils.isNotNull(offset)) {
    sql = SqlBuilderUtil.appendLimit(sql, limit, offset);
  }

  if (domain) {
    opt['domain'] = domain;
  }

  if (mid) {
    opt['mid'] = mid;
  }

  return this.getList(sql, args, opt, cb);
}

DomainDaoSupport.prototype.getCountByWhere = function(where, args, cb) {
  var tableConfig = this.getTableConfig();

  var sql = util.format(SQL_COUNT_SELECT, tableConfig.getTableName(), where);

  return this.getCount(sql, args, cb);
}

DomainDaoSupport.prototype.removeByWhere = function(where, args, cb) {
  var tableConfig = this.getTableConfig();

  var sql = util.format(REMOVE_OBJECT_SELECT, tableConfig.getTableName(), where);

  return this.delete(sql, args, cb);
}

DomainDaoSupport.prototype.addToCache = function(key, value, expire) {
  return this.getCacheTemplate().addToCache(key, value, expire);
}

DomainDaoSupport.prototype.getStringFromCache = function(key, cb) {
  return this.getCacheTemplate().getString(key, cb);
}

DomainDaoSupport.prototype.setCounter = function(key, initCount, expire) {
  return this.getCacheTemplate().setCounter(key, initCount, expire);
}

DomainDaoSupport.prototype.getCounter = function(key, cb) {
  return this.getCacheTemplate().getCounter(key, cb);
}

DomainDaoSupport.prototype.incr = function(key) {
  return this.getCacheTemplate().incr(key)
}

DomainDaoSupport.prototype.incrBy = function(key, increment) {
  return this.getCacheTemplate().incrBy(key, increment);
}

DomainDaoSupport.prototype.removeFromCache = function(key) {
  return this.getCacheTemplate().delFromCache(key);
}

module.exports = DomainDaoSupport;