/**
 * db.js - db object for bcoin
 * Copyright (c) 2014-2015, Fedor Indutny (MIT License)
 * https://github.com/indutny/bcoin
 */

var bcoin = require('../bcoin');
var utils = bcoin.utils;
var assert = utils.assert;
var EventEmitter = require('events').EventEmitter;
var network = bcoin.protocol.network;
var DUMMY = new Buffer([]);

/**
 * BlockDB
 */

function BlockDB(node, options) {
  var self = this;
  var levelup;

  if (!(this instanceof BlockDB))
    return new BlockDB(node, options);

  // Some lazy loading
  levelup = require('levelup');

  EventEmitter.call(this);

  if (!options)
    options = {};

  this.file = options.indexFile;

  bcoin.ensurePrefix();

  if (!this.file)
    this.file = bcoin.prefix + '/block-' + network.type + '.db';

  this.options = options;

  this.node = node;

  this.cache = {
    unspent: new bcoin.lru(32 * 1024 * 1024, function() { return 80; }),
    tx: new bcoin.lru(32 * 1024 * 1024, function(key, tx) { return tx.getSize(); })
  };

  if (+process.env.BCOIN_FRESH === 1 && bcoin.cp)
    bcoin.cp.execFileSync('rm', ['-rf', this.file], { stdio: 'ignore' });

  this.db = new levelup(this.file, {
    keyEncoding: 'ascii',
    valueEncoding: 'binary',
    createIfMissing: true,
    errorIfExists: false,
    compression: true,
    cacheSize: 16 * 1024 * 1024,
    writeBufferSize: 8 * 1024 * 1024,
    // blockSize: 4 * 1024,
    maxOpenFiles: 8192,
    // blockRestartInterval: 16,
    db: bcoin.isBrowser
      ? require('level-js')
      : require('level' + 'down')
  });
}

utils.inherits(BlockDB, EventEmitter);

BlockDB.prototype.close = function close(callback) {
  var self = this;
  this.db.close(function(err) {
    if (err)
      return callback(err);

    return callback();
  });
};

BlockDB.prototype.migrate = function migrate(blockSize, compression, callback) {
  var options, db, pending, stream, total, done;

  callback = utils.once(callback);
  options = utils.merge({}, this.db.options);

  if (blockSize != null)
    options.blockSize = blockSize;

  if (compression != null)
    options.compression = compression;

  options.maxOpenFiles = 60000;

  utils.print('Migrating DB with options:');
  utils.print(options);

  db = levelup(this.file + '.migrated', options);

  stream = this.db.createReadStream();

  pending = 0;
  total = 0;

  function onPut(err) {
    if (err)
      return callback(err);

    if (++total % 10000 === 0)
      utils.print('%d written.', total);

    pending--;

    if (done && !pending)
      callback();
  }

  stream.on('data', function(data) {
    pending++;
    db.put(data.key, data.value, onPut);
  });

  stream.on('error', function(err) {
    callback(err);
  });

  stream.on('end', function() {
    done = true;
    if (!pending)
      callback();
  });
};

BlockDB.prototype.saveBlock = function saveBlock(block, callback) {
  var self = this;
  var batch = this.db.batch();

  batch.put('b/b/' + block.hash('hex'), block.toSmall());

  block.txs.forEach(function(tx, i) {
    batch.put('t/t/' + tx.hash('hex'), tx.toExtended());
  });

  self.connectBlock(block, callback, batch);
};

BlockDB.prototype.removeBlock = function removeBlock(hash, callback) {
  var self = this;

  this._getCoinBlock(hash, function(err, block) {
    var batch;

    if (err)
      return callback(err);

    if (!block)
      return callback();

    batch = self.db.batch();

    function cb(err) {
      if (err)
        return callback(err);

      batch.del('b/b/' + block.hash('hex'));

      block.txs.forEach(function(tx, i) {
        batch.del('t/t/' + tx.hash('hex'));
      });

      return callback(null, block);
    }

    self.disconnectBlock(hash, cb, batch);
  });
};

BlockDB.prototype.connectBlock = function connectBlock(block, callback, batch) {
  var self = this;

  this._getCoinBlock(block, function(err, block) {
    if (err)
      return callback(err);

    if (!block) {
      assert(!batch);
      return callback();
    }

    if (!batch)
      batch = self.db.batch();

    batch.put('b/h/' + block.height, block.hash());

    block.txs.forEach(function(tx, i) {
      var hash = tx.hash('hex');
      var uniq = {};

      tx.inputs.forEach(function(input) {
        var type = input.getType();
        var address = input.getAddress();
        var uaddr;

        if (input.isCoinbase())
          return;

        if (type === 'pubkey' || type === 'multisig')
          address = null;

        uaddr = address;

        if (uaddr) {
          if (!uniq[uaddr])
            uniq[uaddr] = true;
          else
            uaddr = null;
        }

        if (uaddr)
          batch.put('t/a/' + uaddr + '/' + hash, DUMMY);

        if (address) {
          batch.del(
            'u/a/' + address
            + '/' + input.prevout.hash
            + '/' + input.prevout.index);
        }

        batch.del('u/t/' + input.prevout.hash + '/' + input.prevout.index);

        if (self.options.cache)
          self.cache.unspent.remove(input.prevout.hash + '/' + input.prevout.index);
      });

      tx.outputs.forEach(function(output, i) {
        var type = output.getType();
        var address = output.getAddress();
        var uaddr;

        if (type === 'pubkey' || type === 'multisig')
          address = null;

        uaddr = address;

        if (uaddr) {
          if (!uniq[uaddr])
            uniq[uaddr] = true;
          else
            uaddr = null;
        }

        if (uaddr)
          batch.put('t/a/' + uaddr + '/' + hash, DUMMY);

        if (address)
          batch.put('u/a/' + address + '/' + hash + '/' + i, DUMMY);

        batch.put('u/t/' + hash + '/' + i, bcoin.coin(tx, i).toRaw());
      });
    });

    batch.write(function(err) {
      if (err)
        return callback(err);
      self.emit('save block', block);
      return callback(null, block);
    });
  });
};

BlockDB.prototype.disconnectBlock = function disconnectBlock(hash, callback, batch) {
  var self = this;

  this._getCoinBlock(hash, function(err, block) {
    var batch;

    if (err)
      return callback(err);

    if (!block) {
      assert(!batch);
      return callback();
    }

    if (!batch)
      batch = self.db.batch();

    if (typeof hash === 'string')
      assert(block.hash('hex') === hash);

    batch.del('b/h/' + block.height);

    block.txs.forEach(function(tx, i) {
      var hash = tx.hash('hex');
      var uniq = {};

      if (self.options.cache)
        self.cache.tx.remove(hash);

      tx.inputs.forEach(function(input) {
        var type = input.getType();
        var address = input.getAddress();
        var uaddr, coin;

        if (input.isCoinbase())
          return;

        if (type === 'pubkey' || type === 'multisig')
          address = null;

        uaddr = address;

        if (uaddr) {
          if (!uniq[uaddr])
            uniq[uaddr] = true;
          else
            uaddr = null;
        }

        assert(input.output);

        if (uaddr)
          batch.del('t/a/' + uaddr + '/' + hash);

        if (address) {
          batch.put('u/a/' + address
            + '/' + input.prevout.hash
            + '/' + input.prevout.index,
            DUMMY);
        }

        batch.put('u/t/'
          + input.prevout.hash
          + '/' + input.prevout.index,
          input.output.toRaw());
      });

      tx.outputs.forEach(function(output, i) {
        var type = output.getType();
        var address = output.getAddress();
        var uaddr;

        if (type === 'pubkey' || type === 'multisig')
          address = null;

        uaddr = address;

        if (uaddr) {
          if (!uniq[uaddr])
            uniq[uaddr] = true;
          else
            uaddr = null;
        }

        if (uaddr)
          batch.del('t/a/' + uaddr + '/' + hash);

        if (address)
          batch.del('u/a/' + address + '/' + hash + '/' + i);

        batch.del('u/t/' + hash + '/' + i);

        if (self.options.cache)
          self.cache.unspent.remove(hash + '/' + i);
      });
    });

    batch.write(function(err) {
      if (err)
        return callback(err);
      self.emit('remove block', block);
      return callback(null, block);
    });
  });
};

BlockDB.prototype.fillCoins = function fillCoins(txs, callback) {
  var self = this;
  var pending = txs.length;

  callback = utils.asyncify(callback);

  utils.forEach(txs, function(tx, next) {
    self.fillCoin(tx, function(err) {
      if (err)
        return next(err);

      next();
    });
  }, callback);
};

BlockDB.prototype.fillTXs = function fillTXs(txs, callback) {
  var self = this;

  callback = utils.asyncify(callback);

  utils.forEach(txs, function(tx, next) {
    self.fillTX(tx, function(err) {
      if (err)
        return next(err);

      next();
    });
  }, callback);
};

BlockDB.prototype.fillCoin = function fillCoin(tx, callback) {
  var self = this;

  callback = utils.asyncify(callback);

  if (tx.isCoinbase())
    return callback();

  utils.forEach(tx.inputs, function(input, next) {
    if (input.output)
      return next();

    self.getCoin(input.prevout.hash, input.prevout.index, function(err, coin) {
      if (err)
        return callback(err);

      if (coin)
        input.output = coin;

      next();
    });
  }, function(err) {
    if (err)
      return callback(err);
    return callback(null, tx);
  });
};

BlockDB.prototype.fillTX = function fillTX(tx, callback) {
  var self = this;

  callback = utils.asyncify(callback);

  if (tx.isCoinbase())
    return callback();

  utils.forEach(tx.inputs, function(input, next) {
    if (input.output)
      return next();

    self.getTX(input.prevout.hash, function(err, tx) {
      if (err)
        return next(err);

      if (tx) {
        input.output = bcoin.coin(tx, input.prevout.index);
      }

      next();
    });
  }, function(err) {
    if (err)
      return callback(err);
    return callback(null, tx);
  });
};

BlockDB.prototype.getCoinsByAddress = function getCoinsByAddress(addresses, options, callback) {
  var self = this;
  var ids = [];
  var coins = [];

  if (!callback) {
    callback = options;
    options = {};
  }

  if (typeof addresses === 'string')
    addresses = [addresses];

  addresses = utils.uniqs(addresses);

  utils.forEach(addresses, function(address, done) {
    var iter = self.db.db.iterator({
      gte: 'u/a/' + address,
      lte: 'u/a/' + address + '~',
      keys: true,
      values: true,
      fillCache: true,
      keyAsBuffer: false,
      valueAsBuffer: true
    });

    (function next() {
      iter.next(function(err, key, value) {
        var parts, hash, index;

        if (err) {
          return iter.end(function() {
            done(err);
          });
        }

        if (key === undefined) {
          return iter.end(function(err) {
            if (err)
              return done(err);
            done();
          });
        }

        parts = key.split('/');
        hash = parts[3];
        index = +parts[4];

        ids.push([hash, index]);

        next();
      });
    })();
  }, function(err) {
    if (err)
      return callback(err);

    utils.forEach(ids, function(item, next) {
      var hash = item[0];
      var index = item[1];
      self.getCoin(hash, index, function(err, coin) {
        if (err)
          return next(err);

        if (!coin)
          return next();

        if (self.options.cache)
          self.cache.unspent.set(id, coin);

        coins.push(coin);
        next();
      });
    }, function(err) {
      if (err)
        return callback(err);
      return callback(null, coins);
    });
  });
};

BlockDB.prototype.getCoin = function getCoin(hash, index, callback) {
  var self = this;
  var id = 'u/t/' + hash + '/' + index;
  var coin;

  this.db.get(id, function(err, data) {
    if (err) {
      if (err.type === 'NotFoundError')
        return callback();
      return callback(err);
    }

    try {
      coin = bcoin.coin.fromRaw(data);
    } catch (e) {
      return callback(e);
    }

    return callback(null, coin);
  });
};

BlockDB.prototype.getTXByAddress = function getTXByAddress(addresses, options, callback) {
  var self = this;
  var hashes = [];
  var txs = [];
  var have = {};

  if (!callback) {
    callback = options;
    options = {};
  }

  if (typeof addresses === 'string')
    addresses = [addresses];

  addresses = utils.uniqs(addresses);

  utils.forEach(addresses, function(address, done) {
    var iter = self.db.db.iterator({
      gte: 't/a/' + address,
      lte: 't/a/' + address + '~',
      keys: true,
      values: true,
      fillCache: true,
      keyAsBuffer: false,
      valueAsBuffer: true
    });

    (function next() {
      iter.next(function(err, key, value) {
        var hash;

        if (err) {
          return iter.end(function() {
            done(err);
          });
        }

        if (key === undefined) {
          return iter.end(function(err) {
            if (err)
              return done(err);
            done();
          });
        }

        hash = key.split('/')[3];

        if (addresses.length > 1) {
          if (have[hash])
            return next();

          have[hash] = true;
        }

        if (self.options.cache && self.cache.tx.has(hash)) {
          txs.push(self.cache.tx.get(hash));
          return next();
        }

        hashes.push(hash);
      });
    })();
  }, function(err) {
    utils.forEach(hashes, function(hash, next) {
      self.getTX(hash, function(err, tx) {
        if (err)
          return next(err);

        if (!tx)
          return next();

        txs.push(tx);
        next();
      });
    }, function(err) {
      if (err)
        return callback(err);
      return callback(null, txs);
    });
  });
};

BlockDB.prototype.getTX = function getTX(hash, callback) {
  var self = this;
  var id = 't/t/' + hash;
  var tx;

  this.db.get(id, function(err, data) {
    if (err) {
      if (err.type === 'NotFoundError')
        return callback();
      return callback(err);
    }

    try {
      tx = bcoin.tx.fromExtended(data);
    } catch (e) {
      return callback(e);
    }

    if (self.options.paranoid && tx.hash('hex') !== hash)
      return callback(new Error('BlockDB is corrupt. All is lost.'));

    return callback(null, tx);
  });
};

BlockDB.prototype.getFullTX = function getFullTX(hash, callback) {
  var self = this;

  return this.getTX(hash, function(err, tx) {
    if (err)
      return callback(err);

    if (!tx)
      return callback();

    return self.fillTX(tx, function(err) {
      if (err)
        return callback(err);

      return callback(null, tx);
    });
  });
};

BlockDB.prototype.getFullBlock = function getFullBlock(hash, callback) {
  var self = this;

  return this.getBlock(hash, function(err, block) {
    if (err)
      return callback(err);

    if (!block)
      return callback();

    return self.fillTXs(block.txs, function(err) {
      if (err)
        return callback(err);

      return callback(null, block);
    });
  });
};

BlockDB.prototype._getCoinBlock = function _getCoinBlock(hash, callback) {
  var self = this;

  if (hash instanceof bcoin.block)
    return callback(null, hash);

  return this.getBlock(hash, function(err, block) {
    if (err)
      return callback(err);

    if (!block)
      return callback();

    return self.fillBlock(block, callback);
  });
};

BlockDB.prototype.fillBlock = function fillBlock(block, callback) {
  var self = this;

  return this.fillCoins(block.txs, function(err) {
    var coins, i, tx, hash, j, input, id;

    if (err)
      return callback(err);

    coins = {};

    for (i = 0; i < block.txs.length; i++) {
      tx = block.txs[i];
      hash = tx.hash('hex');

      for (j = 0; j < tx.inputs.length; j++) {
        input = tx.inputs[j];
        id = input.prevout.hash + '/' + input.prevout.index;
        if (!input.output && coins[id]) {
          input.output = coins[id];
          delete coins[id];
        }
      }

      for (j = 0; j < tx.outputs.length; j++)
        coins[hash + '/' + j] = bcoin.coin(tx, j);
    }

    return callback(null, block);
  });
};

BlockDB.prototype._getHash = function _getHash(height, callback) {
  if (typeof height === 'string')
    return callback(null, height);

  this.db.get('b/h/' + height, function(err, hash) {
    if (err)
      return callback(err);
    if (!hash)
      return callback();
    return callback(null, utils.toHex(hash));
  });
};

BlockDB.prototype.getBlock = function getBlock(hash, callback) {
  var self = this;
  var id, block;

  return this._getHash(hash, function(err, hash) {
    if (err)
      return callback(err);

    if (!hash)
      return callback();

    id = 'b/b/' + hash;

    self.db.get(id, function(err, data) {
      if (err) {
        if (err.type === 'NotFoundError')
          return callback();
        return callback(err);
      }

      block = bcoin.block.fromSmall(data);
      block.txs = [];

      utils.forEach(block.hashes, function(hash, next, i) {
        self.getTX(hash, function(err, tx) {
          if (err)
            return next(err);

          if (!tx)
            return next(new Error('TX not found.'));

          block.txs[i] = tx;

          next();
        })
      }, function(err) {
        if (err)
          return callback(err);

        delete block.hashes;
        block = new bcoin.block(block);
        return callback(null, block);
      });
    });
  });
};

BlockDB.prototype.hasBlock = function hasBlock(hash, callback) {
  var self = this;
  var id = 'b/b/' + hash;

  if (typeof hash === 'number')
    id = 'b/h/' + hash;

  this.db.get(id, function(err, data) {
    if (err && err.type !== 'NotFoundError')
      return callback(err);

    if (!data)
      return callback(null, false);

    return callback(null, true);
  });
};

BlockDB.prototype.hasCoin = function hasCoin(hash, index, callback) {
  var self = this;
  var id = 'u/t/' + hash + '/' + index;

  this.db.get(id, function(err, data) {
    if (err && err.type !== 'NotFoundError')
      return callback(err);

    if (!data)
      return callback(null, false);

    return callback(null, true);
  });
};

BlockDB.prototype._getTX = function _getTX(hash, callback) {
  if (hash instanceof bcoin.tx)
    return callback(null, hash);
  return this.getTX(hash);
};

BlockDB.prototype._spentTX = function _spentTX(hash, callback) {
  var self = this;
  this._getTX(hash, function(err, tx) {
    var hash, spent;

    if (err)
      return callback(err);

    if (!tx)
      return callback(null, 0, -1);

    hash = tx.hash('hex');
    spent = 0;

    utils.forEach(tx.outputs, function(output, next, i) {
      self.isSpent(hash, i, function(err, result) {
        if (err)
          return next(err);

        if (result)
          spent++;

        next();
      });
    });
  }, function(err) {
    if (err)
      return callback(err);
    return callback(null, spent, tx.outputs.length);
  });
};

// For BIP30
// https://bitcointalk.org/index.php?topic=67738.0
BlockDB.prototype.isUnspentTX = function isUnspentTX(hash, callback) {
  return this._spentTX(hash, function(err, spent, outputs) {
    if (err)
      return callback(err);

    return callback(null, spent < outputs);
  });
};

BlockDB.prototype.isSpentTX = function isSpentTX(hash, callback) {
  return this._spentTX(hash, function(err, spent, outputs) {
    if (err)
      return callback(err);

    return callback(null, spent === outputs);
  });
};

BlockDB.prototype.hasTX = function hasTX(hash, callback) {
  var self = this;
  var id = 't/t/' + hash;

  this.db.get(id, function(err, data) {
    if (err && err.type !== 'NotFoundError')
      return callback(err);

    if (!data)
      return callback(null, false);

    return callback(null, true);
  });
};

BlockDB.prototype.isSpent = function isSpent(hash, index, callback) {
  return this.hasCoin(hash, index, function(err, result) {
    if (err)
      return callback(err);

    return callback(null, !result);
  });
};

BlockDB.prototype.getHeight = function getHeight(callback) {
  var self = this;
  var maxHeight = -1;
  var iter;

  iter = this.db.db.iterator({
    gte: 'b/h',
    lte: 'b/h~',
    keys: true,
    values: false,
    fillCache: false,
    keyAsBuffer: false
  });

  (function next() {
    iter.next(function(err, key, value) {
      var height;

      if (err) {
        return iter.end(function() {
          callback(err);
        });
      }

      if (key === undefined) {
        return iter.end(function(err) {
          if (err)
            return callback(err);
          callback(null, maxHeight);
        });
      }

      height = +key.split('/')[2];
      if (height > maxHeight)
        maxHeight = height;

      next();
    });
  })();
};

BlockDB.prototype.reset = function reset(height, callback, emit) {
  var self = this;
  this.getHeight(function(err, currentHeight) {
    if (err)
      return callback(err);

    if (currentHeight < height)
      return callback(new Error('Cannot reset to height ' + height));

    (function next() {
      if (currentHeight === height)
        return callback();

      self.removeBlock(currentHeight, function(err, block) {
        if (err)
          return callback(err);

        // Emit the blocks we removed.
        if (emit && block)
          emit(block);

        currentHeight--;
        next();
      });
    })();
  });
};

/**
 * Expose
 */

module.exports = BlockDB;