module dbct;

import tango.io.Stdout;

alias char[] string;

/**
 * Implements design by contract
 *   - contract inheritance
 *   - remembers old values (only shallow copy for now)
 */


// >>>>
// >>>> ugly ctfe stuff begins
// >>>>

string strip(string s) {
    int a, b = s.length;

    while (a < s.length && isWhiteSpace(s[a])) a++;
    while (b > 0 && isWhiteSpace(s[b-1])) b--;

    return s[a..b];
}

string head(string s) {
    int a;

    while (a < s.length && !isWhiteSpace(s[a])) a++;

    return s[0..a];
}

string headPar(string s) {
    int a;

    while (a < s.length && ((!isWhiteSpace(s[a]) && s[a] != '(' && s[a] != ',' && s[a] != ')') || a==0)) a++;

    if (a < s.length && s[a] == '(') a++;

    return s[0..a];
}

string methodName(string name, string suffix = "") {
    string tmp = strip(name), tmp2;
    tmp = tmp[head(tmp).length..$];
    tmp = strip(tmp);

    tmp2 = headPar(tmp)[0..$-1];
    tmp = tmp[headPar(tmp).length..$];
    if (suffix != "") tmp2 ~= suffix ~ "(" ~ tmp;

    return tmp2;
}

string methodCall(string name, string suffix = "") {
    string tmp, tmp2;

    tmp = strip(name);
    tmp = strip(tmp[head(tmp).length..$]);

    tmp2 = headPar(tmp);
    tmp = strip(tmp[headPar(tmp).length..$]);

    tmp2 = tmp2[0..$-1] ~ suffix ~ "(";

    string old;
    while (tmp.length) {
        string w = headPar(tmp);
        if (w == "," || w == ")") tmp2 ~= old ~ w ~ " ";
        old = w;
        tmp = strip(tmp[w.length..$]);
    }

    return tmp2;
}

bool isWhiteSpace(char c) {
    return (c == ' ' || c == '\t' || c == '\r' || c == '\n' || c == '\v' || c == '\f');
}

string method(string signature, string _in, string _out, string _body) {
    string retType = head(strip(signature));
    string retType2 = retType == "void" ? "" : retType ~ " result";
    retType = retType == "void" ? "" : "result";
    string outSig = methodName(signature) ~ "_out(";
    string baseMet = "static if (is(typeof(this) xxx == super) && is(typeof(xxx[0]."~methodName(signature);
    string speshul = `__speshul_old_"~typeof(this).stringof~"`;
    return
        // "old object"
        `mixin("static if (!is(typeof(this.` ~ speshul ~ `))) private typeof(this) ` ~ speshul ~ `;");` ~

        // in contract
        baseMet ~ "_in)) && "~ (_in=="" ? "1" : "0") ~ ") {} else { protected void " ~ methodName(signature, "_in") ~ "{" ~ `mixin("`~speshul~` = new typeof(this)();");` ~

        `mixin("foreach(__speshul_idx, __speshul_v; this.tupleof) {
            `~speshul~`.tupleof[__speshul_idx] = __speshul_v;
        }");` ~
            
        _in ~ "}}" ~

        // out contract
        "protected void " ~ outSig ~ retType2 ~ ")" ~ "{" ~ baseMet ~ "_out))) super."~methodName(signature)~"_out("~retType~");" ~ (_in == "" ? "" : `mixin("auto old = `~speshul~`;");`) ~ _out ~ "}" ~

        // method signature
        signature ~

        // second in part
        "in {" ~ methodCall(signature, "_in") ~ ";}" ~

        // second out part
        "out" ~ (retType == "" ? "" : "("~retType~")") ~ "{" ~ outSig ~ retType ~ ")"~ "; }" ~

        // method body
        "body {" ~ _body ~ "}";
}

string method(string signature, string _body) {
    return method(signature, "", "", _body);
}

// >>>>
// >>>> ugly ctfe stuff ends
// >>>>


//
// USAGE
//

class base {
    mixin(method(
        // signature
        `int foobar(int i, int j)`,

        // in
        `Stdout("base.in\n");`,
        //``,

        // out
        `Stdout("base.out\n");`,

        // body
        `return 0;`
    ));
}

class derived : base {
    int a, b;

    mixin(method(
        // signature
        `int foobar(int i, int j)`,

        // in
        `Stdout("derived.in\n");`,

        // out
        `Stdout(old.a).newline;
        Stdout("derived.out\n");`,

        // body
        `a = 42; return 0;`
    ));
}

void main() {
    auto b = new derived;
    auto c = new derived;
    b.foobar(1,2);
    b.foobar(1,2);
}