from dependency_injector import containers, providers

from config import Config
from services.model.mlx_model import MlxModelService
from services.chat.history_service import HistoryService
from services.chat.chat_service import ChatService
from services.chat.compact_service import CompactService
from services.db.mysql_service import DatabaseService
from services.db.conversation_repository import ConversationRepository
from services.ui.cli_service import CliUiService
from services.events.event_bus import EventBus
from services.events.handlers import StreamTokenHandler, StreamEndHandler


class Container(containers.DeclarativeContainer):
    config = providers.Singleton(Config)

    event_bus = providers.Singleton(EventBus)

    model_service = providers.Singleton(
        MlxModelService,
        model_id=providers.Callable(lambda c: c.model_id, config),
    )

    compact_service = providers.Singleton(
        CompactService,
        model=model_service,
    )

    db_service = providers.Singleton(
        DatabaseService,
        host=providers.Callable(lambda c: c.db_host, config),
        port=providers.Callable(lambda c: c.db_port, config),
        db=providers.Callable(lambda c: c.db_name, config),
        user=providers.Callable(lambda c: c.db_user, config),
        password=providers.Callable(lambda c: c.db_password, config),
    )

    conversation_repository = providers.Singleton(
        ConversationRepository,
        db=db_service,
    )

    history_service = providers.Factory(
        HistoryService,
        system_prompt=providers.Callable(lambda c: c.system_prompt, config),
        max_turns=providers.Callable(lambda c: c.max_history_turns, config),
        compact_threshold=providers.Callable(lambda c: c.compact_threshold, config),
        repository=conversation_repository,
        compact_service=compact_service,
    )

    chat_service = providers.Factory(
        ChatService,
        model=model_service,
        history=history_service,
        event_bus=event_bus,
        max_tokens=providers.Callable(lambda c: c.max_tokens, config),
    )

    ui_service = providers.Singleton(CliUiService)

    stream_token_handler = providers.Singleton(StreamTokenHandler)
    stream_end_handler = providers.Singleton(StreamEndHandler)