import tango.io.Console;
import tango.core.Thread;

/***************************************************
  Implementation
 ***************************************************/
struct RecurseGuard {
    Thread[] threads;

    static Object monitor;

    void addThread() {
        auto ct = Thread.getThis;
        synchronized(monitor) {
            foreach (thread; threads) {
                assert(thread != ct, "Recursive call!");
            }
            threads ~= ct;
        }
    }

    void removeThread() {
        auto ct = Thread.getThis;
        synchronized(monitor) {
            foreach(i, thread; threads) {
                if (thread == ct) {
                    threads[i] = threads[$-1];
                    threads = threads[0 .. $-1];
                    return;
                }
            }
        }
        assert(false, "Current thread didn't enter this function (wtf?)");
    }

    alias addThread opCall;
    alias removeThread done;
}

static this() {
    RecurseGuard.monitor = new Object;
}

class TestException : Exception {
    this() {
        super("test");
    }
}

/***************************************************
  Usage
 ***************************************************/
void testFunction(bool recurse) {
    static RecurseGuard guard;

    guard();
    scope(exit) guard.done;

    Thread.sleep(1); // Pretend to be working
    if (recurse) {
        testFunction(false);
    }
}

void testBadFunction() {
    static RecurseGuard guard;

    guard();
    scope(exit) guard.done;

    Thread.sleep(1);
    throw new TestException;
}

/***************************************************
  Tests
 ***************************************************/
void testPositive() {
    try {
        Cout("Positive test... ").flush;
        testFunction(false);
        Cout("Passed").newline;
    } catch (Exception e) {
        Cout("Failed").newline;
    }
}

void testNegative() {
    try {
        Cout("Negative test... ").flush;
        testFunction(true);
        Cout("Failed").newline;
    } catch (Exception e) {
        Cout("Passed").newline;
    }
}

void testException() {
    try {
        Cout("Positive test with exception... ").flush;
        testBadFunction;
        Cout("Failed").newline;
    } catch (TestException e) {
        Cout("Passed").newline;
    } catch (Exception e) {
        Cout("Failed").newline;
    }
}

void testThreads() {
    try {
        Cout("Positive threaded test... ").flush;
        Thread[] threads;
        for (int i = 0; i < 100; i++){
            threads ~= new Thread({testFunction(false);});
            threads[$-1].start;
        }

        foreach (thread; threads)
            thread.join;

        Cout("Passed").newline;
    } catch (Exception e) {
        Cout("Failed").newline;
    }
}

void main() {
    testPositive;
    testNegative;
    testException;
    testThreads;
}