class Foo {
    constructor(dm: DependencyProvider) {}
    foo() { console.log('foo'); }
}

class MockFoo extends Foo {
    foo() { console.log('mocked foo'); }
}

class Bar {
    foo: Foo;
    constructor(dm: DependencyProvider) {
        this.foo = dm.getProviderFor(Foo)();
    }
    bar() { console.log('bar'); }
}

class MockBar extends Bar {
    bar() { console.log('mocked bar'); }
}

class DependencyProvider {
    private providers: Map<string, () => any> = new Map();
    setProviderFor<T>(ctor: { new(DependencyManager): T }, provider: () => T) {
        this.providers.set(ctor.name, provider);
    }
    getProviderFor<T>(ctor: { new(DependencyManager): T }): () => T {
        const provider = this.providers.get(ctor.name);
        if (!provider) {
            throw new Error(`No provider registered for type ${ctor.name}`);
        }
        return provider;
    }
}

class DefaultDependencyProvider extends DependencyProvider {
    constructor() {
        super();
        this.setProviderFor(Foo, () => new Foo(this));
        this.setProviderFor(Bar, () => new Bar(this));
    }
}

class NotRegistered {}

console.log('default injection');
const d = new DefaultDependencyProvider();
d.getProviderFor(Foo)().foo();
d.getProviderFor(Bar)().bar();
d.getProviderFor(Bar)().foo.foo();

console.log('mocked injection');
d.setProviderFor(Foo, () => new MockFoo(d));
d.getProviderFor(Foo)().foo();
d.getProviderFor(Bar)().bar();
d.getProviderFor(Bar)().foo.foo();


console.log('invalid injection');
try {
    d.getProviderFor(NotRegistered)();
} catch (e) {
    console.log(e);
}