let st = {};
let n = {};
//-----------------------------------------
//-----------------------------------------
function* new_node() {
    let r = yield* st.get_max_node_id()
    let id = r.id
    var new_id = id + 1
    yield* st.insert_node(new_id, id, n.NEWNODE)
    return new_id
}
//-----------------------------------------
function* new_name(name) {
    var id = yield* new_node()
    yield* st.insert_dsc(id, name)
    n[name] = id
    return id
}
//-----------------------------------------
let initDb = (function() {
    let Promise = require("bluebird");
    let db = require('sqlite');
    //-----------------------------------------
    function* create_sts() {
        let m = {
            get_max_node_id: 'select max(id) id from node',
            get_val: 'select v from val where id=? and c=?',
            insert_node: 'insert into node(id,a,b) values(?,?,?)',
            insert_val: 'insert into val(id,c,v) values(?,?,?)',
            insert_dsc: 'insert into dsc(id,name) values(?,?)',
            all_dsc: 'select * from dsc',
            all_node: 'select * from node',
            get_node_a_b: 'select id from node where a=? and b=?',
            get_node_id: 'select * from node where id=?',
        }

        function fn_get(a) {
            return function*() {
                return (yield a.all.apply(a, arguments))[0]
            }
        }

        function fn_all(a) {
            return function*() {
                return (yield a.all.apply(a, arguments))
            }
        }

        function fn_run(a) {
            return function*() {
                return (yield a.run.apply(a, arguments))
            }
        }
        for (var i in m) {
            var stm = yield db.prepare(m[i]);
            var r = i.match(/^([^_]+)_/)
            var p = r ? r[1] : '';
            switch (p) {
                case 'get':
                    st[i] = fn_get(stm);
                    break;
                case 'all':
                    st[i] = fn_all(stm);
                    break;
                default:
                    st[i] = fn_run(stm);
                    break;
            }
        }
        st.commit = function*() {
            yield db.exec('commit');
            yield db.exec('begin');
        }
        st.rollback = function*() {
            yield db.exec('rollback');
            yield db.exec('begin');
        }
    }
    //-----------------------------------------
    function* get_named_nodes() {
        let m = yield* st.all_dsc();
        m.map((v) => {
            n[v.name] = v.id;
        });
        if (m.length < 3) {
            //-------------------------
            yield* new_name('BYTE0')
            for (var i = 1; i < 0xFF; i++) {
                yield* new_node()
            }
            yield* new_name('BYTEFF')
            //-------------------------
            let s = 'NEXT,PROTO,IN,OUT,LIST,CREATE,BEGIN,END,ADD,CURRENT,VAL'.split(',');
            for (var i in s) {
                yield* new_name(s[i])
            }
        }
    }
    //-----------------------------------------
    return function*() {
        yield db.open('./a.sqlite3', {
            Promise
        });
        yield db.run('PRAGMA foreign_keys = ON')
        yield db.migrate({
            force: 'last'
        });
        yield db.run('begin')
        yield* create_sts();
        yield* get_named_nodes();
    }
})();
//-----------------------------------------
function* link1(a, b) {
    var r = yield* st.get_node_a_b(a, b)
    if (r) return r.id
    r = yield* st.get_max_node_id()
    var new_id = r.id + 1
    yield* st.insert_node(new_id, a, b)
    return new_id
}
//-----------------------------------------
function* link(first, ...ns) {
    var t = first;
    for (var i = 0, l = ns.length; i < l; i++) {
        t = yield* link1(t, ns[i]);
    }
    return t;
}
//-----------------------------------------
function* new_child_ctx(c) {
    var id = new_node();
    set(id, n.PROTO, id, c)
}
//-----------------------------------------
function* set1(c, v, n) {
    yield* st.insert_val(n, c, v)
}
//-----------------------------------------
function* set(c, v, ...ns) {
    yield* set1(c, v, yield* link(...ns));
}
//-----------------------------------------
function* get_parent_ctx(c) {
    var t = yield* link1(c, n.PROTO)
    var r = yield* st.get_val(t, c)
    if (r) return r.v
    return n.NIL
}
//-----------------------------------------
function* get1(c, n) {
    var r = yield* st.get_val(n, c)
    if (r) return r.v
    if (c === n.NIL) return n.NIL
    return yield* get1(n, yield* get_parent_ctx(c));
}
//-----------------------------------------
function* get(c, ...ns) {
    return yield* get1(c, yield* link(...ns));
}
//-----------------------------------------
function* from_buffer(buf) {
    if (!(buf && buf.length)) return NIL;
    var l = buf.length;
    if (l == 1) return n.BYTE0 + buf.readUInt8(0);
    var s = (l >> 1) + (l & 1);
    return yield* link1(yield* from_buffer(buf.slice(0, s)), yield* from_buffer(buf.slice(s)));
}
//-------------------------------
function* to_buffer(node) {
    if (node == n.NIL) throw new Error('bad node');
    if (node <= n.BYTEFF && node >= n.BYTE0) {
        var b = Buffer.alloc(1);
        b.writeUInt8(node - n.BYTE0, 0);
        return b;
    }
    var r = yield* st.get_node_id(node)
    return Buffer.concat([yield* to_buffer(r.a), yield* to_buffer(r.b)]);
}
//-----------------------------------------
function* from_str(s) {
    var b = Buffer.from(s);
    return yield* from_buffer(b);
}
//-----------------------------------------
function* to_str(n) {
    return (yield* to_buffer(n)).toString();
}
//-----------------------------------------
function* main() {
    yield* initDb();
    st.commit();
    console.time('start');
    let r = yield* from_str('testzzzaa')
    console.log(r);
    let t = yield* to_str(r)
    console.log(t);
    // var t = yield* new_node();
    // for (var i = 0; i < 200; i++) {
    //     t = yield* link(t, n.NEXT);
    // }
    console.timeEnd('start')
    // yield* st_insert_node.run(1, 1, 1);
    // yield* st_insert_node.run(2, 1, 2);
    //var r = yield* st.all_node()
    //console.log(r);
    yield* st.commit()
}
//-----------------------------------------
require('co')(main).catch(function(err) {
    console.error(err);
    throw err;
});