module main;

import std.stdio;
import std.string;
import std.conv;
import std.file;
import std.ascii;

enum Operation {
EMPTY, VALUE, IS, AND, OR, LSHIFT, RSHIFT, NOT
}

class Node {
    Node[] deps;
    Operation operation;
    string name;
    ushort value;
    bool   computed = false;

    this() {
        value = 0;
    }

    this(ushort val) {
        value = val;
        operation = Operation.VALUE;
        computed = true;
    }

    this(string nm) {
        name = nm.idup;
        operation = Operation.EMPTY;
    }

    this(string nm, Operation oper) {
        name = nm.idup;
        operation = oper;
    }

    void setOperation(Operation op) {
        operation = op;
    }

//TODO
    void print() {
        switch(operation) {
            case Operation.AND:
                write(name);
                write("{");
                deps[0].print();
                write("} AND {");
                deps[1].print();
                write("}");
                break;
            case Operation.OR:
                write(name);
                write("{");
                deps[0].print();
                write("} OR {");
                deps[1].print();
                write("}");
                break;
            case Operation.NOT:
                write(name);
                write("{");
                write("NOT {");
                deps[0].print();
                write("}}");
                break;
            case Operation.LSHIFT:
                write(name);
                write("{");
                deps[0].print();
                write("} << {");
                deps[1].print();
                write("}");
                break;
            case Operation.RSHIFT:
                write(name);
                write("{");
                deps[0].print();
                write("} >> {");
                deps[1].print();
                write("}");
                break;
            case Operation.IS:
                write(name);
                write("{");
                deps[0].print();
                write("}");
                break;
            case Operation.VALUE:
                write(getValue());
                break;
            default:
                writeln("NO OPERATION!");
                break;
        }
    }

    string getName() {
        return name;
    }

    ushort getValue() {
        return value;
    }

    string getString() {
        string result;
        if(operation == Operation.VALUE)
            result = to!string(value);
        else
            result = name;
        return result;
    }

    void addDep(Node dep) {
        deps = deps ~ dep;
    }

    ushort getResult() {
        ushort x, y, result = 0;
        if (computed) {
            result = value;
        }
        else {
        switch(operation) {
            case Operation.AND:
            case Operation.OR:
            case Operation.RSHIFT:
            case Operation.LSHIFT:
                x = deps[0].getResult();
                y = deps[1].getResult();
                switch(operation) {
                    case Operation.AND:
                        result = x & y;
                        break;
                    case Operation.OR:
                        result = x | y;
                        break;
                    case Operation.LSHIFT:
                        result = cast(ushort)(x << y);
                        break;
                    case Operation.RSHIFT:
                        result = cast(ushort)(x >>> y);
                        break;
                    default:
                        break;
                }
                value = result;
                computed = true;
                break;
            case Operation.NOT:
                x = deps[0].getResult();
                result = ~x;
                value = result;
                computed = true;
                break;
            case Operation.IS:
                result = deps[0].getResult();
                value = result;
                computed = true;
                break;
            case Operation.VALUE:
                result = value;
                break;
            default:
                writeln("EMPTY!");
                break;
            }
        }
        return result;
    }
}



int main(string[] args)
{
    Node[] nodes;
    nodes.length = 0;

    Node contains(string name) {
        foreach(Node node; nodes) {
            if(cmp(node.getName(), name) == 0)
                return node;
        }
        return null;
    }

    void addParameter(Node node, string param) {
        Node nodeChild;
        if(isDigit(param[0])) {
            nodeChild = new Node(to!ushort(param));
            node.addDep(nodeChild);
        } else {
            nodeChild = contains(param);
            if (nodeChild is null) {
                writeln("..creating new child1, name = " ~ param);
                nodeChild = new Node(param);
                nodes = nodes ~ nodeChild;
            }
            node.addDep(nodeChild);
        }
    }

    void parse(string str) {
        Node node, nodeChild1, nodeChild2;
        auto lexems = split(str);
        writeln(lexems);
        string name, expr, param1, param2;

        foreach(k, word; lexems) {
            if (cmp(word, "->") == 0) {
                name = lexems[k+1];
                writeln("name: "~ name);

                node = contains(name);
                if (node is null) {
                    writeln("..creating new..");
                    node = new Node(name);
                    nodes = nodes ~ node;
                }

                if (lexems.length > 3) {
                    expr = lexems[k-2];

                    if(cmp(expr, "AND") == 0){
                        node.setOperation(Operation.AND);
                        param1 = lexems[k-3];
                        param2 = lexems[k-1];
                        addParameter(node, param1);
                        addParameter(node, param2);

                    }
                    else if(cmp(expr, "OR") == 0) {
                        node.setOperation(Operation.OR);
                        param1 = lexems[k-3];
                        param2 = lexems[k-1];
                        addParameter(node, param1);
                        addParameter(node, param2);
                    }
                    else if(cmp(expr, "NOT") == 0) {
                        node.setOperation(Operation.NOT);
                        param1 = lexems[k-1];
                        addParameter(node, param1);
                    }

                    else if(cmp(expr, "LSHIFT") == 0) {
                        node.setOperation(Operation.LSHIFT);
                        param1 = lexems[k-3];
                        param2 = lexems[k-1];
                        addParameter(node, param1);
                        addParameter(node, param2);
                    }

                    else if(cmp(expr, "RSHIFT") == 0) {
                        node.setOperation(Operation.RSHIFT);
                        param1 = lexems[k-3];
                        param2 = lexems[k-1];
                        addParameter(node, param1);
                        addParameter(node, param2);
                    }
                }
                else {
                    param1 = lexems[k-1];
                    node.setOperation(Operation.IS);
                    addParameter(node, param1);
                }
            }
        }
    }

    foreach(char[] line; File("input3.txt").byLine()) {
        string s = line.dup;
        parse(s);
    }

    writeln("===");
    foreach(Node n; nodes) {
        if(cmp(n.getName(), "a") == 0)
        {
            writeln();
            writeln("a = " ~ to!string(n.getResult()));
            break;
        }
    }


    return 0;
}