from typing import List, Callable, Concatenate, Awaitable
from abc import ABC, abstractmethod
from punq import Container

from kernel.feature.provider import Provider
from kernel.application.kernel import Kernel

class Application(ABC):
    __kernel: Kernel
    __features: List[Provider]

    @abstractmethod
    async def do(
        self,
        callback: Callable[Concatenate[Container, ...], Awaitable[None]]
    ) -> None:
        pass

    def __init__(self, kernel: Kernel, features: List[type[Provider]]) -> None:
        self.__kernel = kernel
        self.__features = []

        for feature in features:
            feature_instance = feature(kernel.get_container())
            feature_instance.register()

            self.__features.append(feature_instance)

    async def launch(
        self,
        callback: Callable[Concatenate[Container, ...], Awaitable[None]]
    ) -> None:
        for feature in self.__features:
            feature.bootstrap()

        await self.do(callback)

    def get_container(self) -> Container:
        return self.__kernel.get_container()