var bignum = require('bignum');
var multiHashing = require('multi-hashing');
var util = require('./util.js');


var algos = module.exports = global.algos = {
    sha256: {
        //Uncomment diff if you want to use hardcoded truncated diff
        //diff: new Buffer('00000000ffff0000000000000000000000000000000000000000000000000000', 'hex'),
        shift: 32,
        multiplier: Math.pow(2, 32),
        hash: function(){
            return function(){
                return util.sha256d.apply(this, arguments);
            }
        }
    },
    scrypt: {
        //Uncomment diff if you want to use hardcoded truncated diff
        //diff: new Buffer('0000ffff00000000000000000000000000000000000000000000000000000000', 'hex'),
        shift: 20,
        multiplier: Math.pow(2, 16),
        hash: function(){
            return function(){
                return multiHashing.scrypt.apply(this, arguments);
            }
        }
    },
    'scrypt-jane': {
        shift: 20,
        multiplier: Math.pow(2, 16),
        hash: function(coinConfig){
            var nTimestamp = coinConfig.chainStartTime || 1367991200;
            var nMin = coinConfig.nMin || 4;
            var nMax = coinConfig.nMax || 30;
            return function(data, nTime){
                return multiHashing.scryptjane(data, nTime, nTimestamp, nMin, nMax);
            }
        }
    },
    'scrypt-n': {
        shift: 20,
        multiplier: Math.pow(2, 16),
        hash: function(coinConfig){

            var timeTable = coinConfig.timeTable || {
                "2048": 1389306217, "4096": 1456415081, "8192": 1506746729, "16384": 1557078377, "32768": 1657741673,
                "65536": 1859068265, "131072": 2060394857, "262144": 1722307603, "524288": 1769642992
            };

            var nFactor = (function(){
                var n = Object.keys(timeTable).sort().reverse().filter(function(nKey){
                    return Date.now() / 1000 > timeTable[nKey];
                })[0];

                var nInt = parseInt(n);
                return Math.log(nInt) / Math.log(2);
            })();

            return function(data) {
                return multiHashing.scryptn(data, nFactor);
            }
        }
    },
    x11: {
        shift: 20,
        multiplier: Math.pow(2, 32.3),
        hash: function(){
            return function(){
                return multiHashing.x11.apply(this, arguments);
            }
        }
    },
    quark: {
        shift: 20,
        multipler: Math.pow(2, 16),
        hash: function(){
            return function(){
                return multiHashing.quark.apply(this, arguments);
            }
        }
    },
    skein: {
        shift: 20,
        hash: function(){
            return function(){
                return multiHashing.skein.apply(this, arguments);
            }
        }
    },
    bcrypt: {
        shift: 11,
        hash: function(){
            return function(){
                return multiHashing.bcrypt.apply(this, arguments);
            }
        }
    },
    keccak: {
        shift: 24,
        multiplier: Math.pow(2, 24),
        hash: function(coinConfig){
            if (coinConfig.normalHashing === true) {
                return function (data, nTimeInt) {
                    return multiHashing.keccak(multiHashing.keccak(Buffer.concat([data, new Buffer(nTimeInt.toString(16), 'hex')])));
                };
            }
            else {
                return function (data) {
                    return multiHashing.keccak(data);
                }
            }
        }
    },
    blake: {
        shift: 24,
        hash: function(){
            return function(){

            }
        }
    },
    fugue: {
        shift: 24,
        hash: function(){
            return function(){

            }
        }
    },
    shavite: {
        shift: 20,
        hash: function(){
            return function(){

            }
        }
    },
    hefty1: {
        shift: 16,
        hash: function(){
            return function(){

            }
        }
    }
};


for (var algo in algos){
    if (!algos[algo].diff) {
        algos[algo].nonTruncatedDiff = util.shiftMax256Right(algos[algo].shift);
        algos[algo].bits = util.bufferToCompactBits(algos[algo].nonTruncatedDiff);
        algos[algo].diff = util.convertBitsToBuff(algos[algo].bits);
    }
}