import json
import os

from dependency_injector import providers, containers
from firebase_admin import credentials
from openai import AsyncOpenAI
from httpx import AsyncClient as HTTPClient
from google.cloud.firestore_v1 import AsyncClient as FirestoreClient
from dotenv import load_dotenv
from sentence_transformers import SentenceTransformer

from app.repositories.impl import *
from app.services.impl import *
from app.controllers.impl import *

load_dotenv()


def config_di(
        *, polly_client: any, http_client: HTTPClient, whisper_model: any
) -> None:
    """
        Loads up all the common configs of all the environments
        and then calls the specific env configs
    """
    # Firebase token
    cred = credentials.Certificate(os.getenv("GOOGLE_APPLICATION_CREDENTIALS"))
    firebase_token = cred.get_access_token().access_token

    container = containers.DynamicContainer()

    openai_client = providers.Singleton(AsyncOpenAI)
    polly_client = providers.Object(polly_client)
    http_client = providers.Object(http_client)
    firestore_client = providers.Singleton(FirestoreClient)
    whisper_model = providers.Object(whisper_model)

    llm = providers.Factory(OpenAI, client=openai_client)
    stt = providers.Factory(OpenAIWhisper, model=whisper_model)
    tts = providers.Factory(AWSPolly, client=polly_client)
    vid_gen = providers.Factory(Heygen, client=http_client, heygen_token=os.getenv("HEY_GEN_TOKEN"))
    ai_detector = providers.Factory(GPTZero, client=http_client, gpt_zero_key=os.getenv("GPT_ZERO_API_KEY"))

    firebase_instance = providers.Factory(
        FirebaseStorage, client=http_client, token=firebase_token, bucket=os.getenv("FIREBASE_BUCKET")
    )

    firestore = providers.Factory(Firestore, client=firestore_client)

    # Services

    listening_service = providers.Factory(
        ListeningService, llm=llm, tts=tts, file_storage=firebase_instance, document_store=firestore
    )
    reading_service = providers.Factory(ReadingService, llm=llm)

    speaking_service = providers.Factory(
        SpeakingService, llm=llm, vid_gen=vid_gen,
        file_storage=firebase_instance, document_store=firestore,
        stt=stt
    )

    writing_service = providers.Factory(WritingService, llm=llm, ai_detector=ai_detector)

    with open('app/services/impl/level/mc_variants.json', 'r') as file:
        mc_variants = json.load(file)

    level_service = providers.Factory(
        LevelService, llm=llm, document_store=firestore, mc_variants=mc_variants, reading_service=reading_service,
        writing_service=writing_service, speaking_service=speaking_service, listening_service=listening_service
    )

    grade_service = providers.Factory(
        GradeService, llm=llm
    )

    embeddings = SentenceTransformer('all-MiniLM-L6-v2')

    training_kb = providers.Factory(
        TrainingContentKnowledgeBase, embeddings=embeddings
    )

    training_service = providers.Factory(
        TrainingService, llm=llm, firestore=firestore, training_kb=training_kb
    )

    # Controllers

    container.grade_controller = providers.Factory(
        GradeController, grade_service=grade_service, speaking_service=speaking_service, writing_service=writing_service
    )

    container.training_controller = providers.Factory(
        TrainingController, training_service=training_service
    )

    container.level_controller = providers.Factory(
        LevelController, level_service=level_service
    )
    container.listening_controller = providers.Factory(
        ListeningController, listening_service=listening_service
    )

    container.reading_controller = providers.Factory(
        ReadingController, reading_service=reading_service
    )

    container.speaking_controller = providers.Factory(
        SpeakingController, speaking_service=speaking_service
    )

    container.writing_controller = providers.Factory(
        WritingController, writing_service=writing_service
    )

    container.llm = llm

    container.wire(
        packages=["app"]
    )