module build_constraint

// parsing:
struct BParser {
    tokens []Token
mut:
    pos int
}

fn (mut p BParser) peek(n int) Token {
    if p.pos + n >= p.tokens.len {
        return Token{
            kind: .teof
        }
    }
    t := p.tokens[p.pos + n]
    return t
}

fn (mut p BParser) next() {
    p.pos++
}

fn (mut p BParser) parse() !BExpr {
    return p.expr()
}

fn (mut p BParser) expr() !BExpr {
    return BExpr{
        expr: p.or_expr()!
    }
}

fn (mut p BParser) or_expr() !BOr {
    mut exprs := []BAnd{}
    exprs << p.and_expr()!
    for t := p.peek(0); t.kind == .tor; t = p.peek(0) {
        p.next()
        exprs << p.and_expr()!
    }
    return BOr{
        exprs: exprs
    }
}

fn (mut p BParser) and_expr() !BAnd {
    mut exprs := []BUnary{}
    exprs << p.unary_expr()!
    for t := p.peek(0); t.kind == .tand; t = p.peek(0) {
        p.next()
        exprs << p.unary_expr()!
    }
    return BAnd{
        exprs: exprs
    }
}

fn (mut p BParser) unary_expr() !BUnary {
    t := p.peek(0)
    match t.kind {
        .tfact {
            p.next()
            return BUnary(BFact(t.value))
        }
        .tdefine {
            p.next()
            return BUnary(BDefine(t.value))
        }
        .tnot {
            p.next()
            nt := p.peek(0)
            if nt.kind in [.tfact, .tdefine] {
                ident := p.unary_expr()!
                return BNot{
                    expr: ident
                }
            }
            expr := p.expr()!
            return BNot{
                expr: expr
            }
        }
        .tparen_open {
            p.next()
            expr := p.expr()!
            if p.peek(0).kind != .tparen_close {
                return error('expected closing )')
            }
            p.next()
            return BUnary(expr)
        }
        else {}
    }

    return error('unary failed, unexpected ${t}')
}