from applauncher.kernel import Environments, Kernel
import rest_api.bundle
import myweb.bundle

bundle_list = [
    rest_api.bundle.RestApiBundle(),
    myweb.bundle.WebBundle(),
]

with Kernel(Environments.DEVELOPMENT, bundle_list) as kernel:
   kernel.wait()

from applauncher.kernel import KernelReadyEvent, Configuration, KernelShutdownEvent, Kernel, InjectorReadyEvent
import inject

class RestApiBundle(object):
    def __init__(self):
        # The configuration of this bundle. Just an schema about the data required. The kernel will use it to read
        # configuration files, check that everything is fine and provide it to your application.
        self.config_mapping = {
            "rest_api": {
                "use_debugger": True,
                "port": 3003

            }
        }
        # Other bundles will populate this array with their controllers
        self.blueprints = [index_blueprint]
        # This bundle provides an "object" to allow other bundles add new controllers. Its like this bundle "publish" this object
        # to the kernel and other bundles request this object from the kernel.
        self.injection_bindings = {
            ApiBlueprints: self.blueprints
        }
        # This is done with dependency injection which is a very important step. When all dependencies are ready, an
        # event is thrown (there are more type of events of course) so you have to subscribe if you want to be notified
        self.event_listeners = [
            (KernelReadyEvent, self.kernel_ready),
            (KernelShutdownEvent, self.kernel_shutdown)
        ]
    
    @inject.params(kernel=Kernel)
    def kernel_ready(self, event, kernel):
        # In this case I am only interested when the kernel is ready (the last step, when dependency injection,
        # configuration... are loaded)
        # Just request the kernel to run your server as a service (don't create threads manually)
        kernel.run_service(self.start_server)

    # Start the server. See how I inject the configuration. The kernel was in charge to load the configuration and
    # prepare everything else
    @inject.params(config=Configuration)
    def start_sever(self, config):
        app = Flask("MyApi")
        # As we are executing this after all other bundles are loaded (because of KernelReadyEvent), all other bundles
        # should have appended his blueprints into out blueprints array.
        for blueprint in self.blueprints:
            # Just register it into flask
            app.register_blueprint(blueprint)

        # Finally run the server. Its like a normal application but the kernel simplified our work, in this case by
        # providing the configuration and communication with other bundles
        app.run(use_debugger=False, port=config)

     def kernel_shutdown(self, event):
        # Do here whatever is needed to stop your server

#Flask blueprint and an example controller
my_blueprint = Blueprint(
    'myApp', __name__
)


@mp_blueprint.route("/lol", methods=['GET'])
def my_app_get_index():
    return jsonify({"foo": "bar"})


# The bundle
class WebBundle(object):
    def __init__(self):
        # I dont need any configuration so I simply ignore the field config_mapping
        self.event_listeners = [
            (InjectorReadyEvent, self.event_listener)
        ]

    def event_listener(self, event):
        # When the injection is ready, we request the blueprints array
        # provided by the WebApiBundl
        bp = inject.instance(ApiBlueprints)
        bp.append(my_blueprint)
        # that's all, later the WebApiBundle will run this blueprint