var fs = require('fs');
var text = fs.readFileSync(process.argv[3], 'binary').toString();
if (process.argv[2] === 'encode') {
    try {
        var result = encode(text);
    } catch (err) {
        console.log(err.name + err.message);
    }
    fs.writeFileSync(process.argv[4], result, 'binary');
    fs.writeFileSync(process.argv[5], '', 'binary');
}

if (process.argv[2] === 'decode') {
    try {
        var result = decode(text);
    } catch (err) {
        console.log(err.name + err.message);
    }
    fs.writeFileSync('out.txt', result, 'binary');
}

function encode(text) {
    var stat = [];
    var count = 0;
    for (var i = 0; i < text.length; i++) {
        var letter = text.charAt(i);
        if (!(letter in stat)) {
            stat[letter] = 0;
            count++;
        }
        stat[letter]++;
    }
    var thCompr = theorCompression(stat, text).toFixed(2);
    var arr = sortObjects(count, stat);
    var tree = getTree(arr.slice());
    var result = {};
    for (var i = 0; i < arr.length; i++) {
        var currCode = "";
        result[arr[i].key] = findCode(arr[i].key, tree, currCode);
        createTable(arr[i].key, result[arr[i].key]);
    }
    console.log(result);
    var out = "";
    for (var i = 0; i < text.length; i++) {
        out += result[text[i]];
    }
    console.log(out);
    var resCompt=(resultinCompression(text, out).toFixed(2));
    return out;
}
function decode(text) {
    var file = fs.readFileSync('table.txt', 'binary').split("\n");
    try {
        var codes = tableParse(file);
    } catch (err) {
        console.log(err.name + err.message);
    }
    var result = "";
    var currCount = 1;
    var ispCount = 0;
    for (var i = 0; i < text.length; i++) {
        var currentCode = text.substr(ispCount, currCount);
        if (typeof codes[currentCode] === 'undefined') {
            currCount += 1;
        } else {
            result += codes[currentCode];
            ispCount += currCount;
            currCount = 1;
        }
    }
    if (ispCount < text.length) {
        fs.writeFileSync(process.argv[4], result, 'binary');
        throw new Error(": Incorrect input");
    }
    return result;
}

function tableParse(file) {
    var codes = {};
    for (var i in file) {
        var str = file[i];
        j = 3;
        var code = '';
        while (str[j] == '0' || str[j] == '1') {
            code += str[j++];
            if ((parseInt(str[j]) > 1 || parseInt(str[j - 1]) > 1)) {
                throw new Error(": Invalid table");
            }
        }
        codes[code] = str[1];
    }
    return codes;
}
function sortObjects(count, stat) {
    var arr = [];
    for (var j = 0; j < count + 1; j++) {
        var minVal = 10000;
        var minSym = '';
        for (var x in stat) {
            if (stat[x] < minVal && stat[x] != 0) {
                minVal = stat[x];
                minSym = x;
            }
        }
        if (minVal != 10000 && minVal > 0) {
            arr.push({
                key: minSym,
                value: minVal
            });
        }
        stat[minSym] = 0;
    }
    return arr;
}
function findCode(ch, node, currCode) {
    if (node.key == ch) {
        return currCode;
    }
    if ((node.child1.key).indexOf(ch, 0) != -1) {
        currCode += '0';
        return findCode(ch, node.child1, currCode);
    } else {
        currCode += '1';
        return findCode(ch, node.child2, currCode);
    }
}

function theorCompression(stat, text) {
    var entropy = 0;
    for (var x in stat) {
        var P = stat[x] / (text.length);
        entropy -= P * Math.log(P);
    }
    if (entropy != 0)
        return (8/(entropy / Math.log(2) ));
    else {
        entropy=8;
        return (8/entropy);
    }
}
function resultinCompression(text, out) {
    return (out.length / 8) / text.length;
}

function createTable(key, value) {
    fs.appendFile('table.txt', ' ' + key + ' ' + value + '\n', 'binary');
}

function getTree(letters) {
    while (letters.length > 1) {
        var child1 = letters[0];
        letters.shift();
        var child2 = letters[0];
        letters.shift();
        var tree = {
            key: child1.key + child2.key,
            value: child2.value + child1.value,
            child1: child1,
            child2: child2
        };
        var i = 0;
        while ((letters.length > i) && (letters[i].value < tree.value))
            i++;
        letters.splice(i, 0, tree);
    }
    return letters[0];
}