import logging

from attr import asdict
from requests import Response, Session
from requests.adapters import HTTPAdapter, Retry
from ui_automation_framework.utils import CoreConfig
from ui_automation_framework.utils import logger as cl

from app.src.api.api_client import ApiClient as CommonClient
from app.src.api.apollo_api import ApolloApiClient
from app.src.api.delphi import DelphiApiClient
from app.src.api.dsp_api import DspApiClient
from app.src.api.gate_api import GateApiClient
from app.src.api.models.auth_model import AuthData, AuthDataDelphi, AuthResponse, AuthResponseDelphi

logger = cl.Logger(logging.DEBUG)


def response_logging_hook(r: Response, *args, **kwargs):
    # logger.info("#" * 150)
    # logger.info(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
    # logger.info(f"{r.request.method} request to {r.request.url}")
    # logger.info(f"Request body is {r.request.body}")
    # logger.info(f"Response text is {r.text}")
    # logger.info(f"Response status code is {r.status_code}")
    # logger.info(f"Server response time is {r.elapsed.microseconds / 1000} milliseconds")
    # logger.info("#" * 150)
    if r.status_code == 401:
        print(r.text)
    if not r.status_code == 429:
        r.raise_for_status()


class ApiClient:
    session_tokens = {}

    def __init__(self, host_endpoint=CoreConfig.TARGET_API_URL, delphi_host_endpoint=CoreConfig.DELPHI_API_URL):
        self.host_endpoint = host_endpoint
        self.delphi_host_endpoint = delphi_host_endpoint
        self.session = Session()
        self.session.hooks["response"] = response_logging_hook
        self.common = CommonClient(self.session, self.host_endpoint)
        self.apollo = ApolloApiClient(self.session, self.host_endpoint)
        self.dsp = DspApiClient(self.session, self.host_endpoint)
        self.gate = GateApiClient(self.session, self.host_endpoint)
        self.delphi = DelphiApiClient(self.session, self.delphi_host_endpoint)

    def authorize(self, auth_model=AuthData(), env="DEV"):
        auth_method = {"DEV": self.authorize_dev, "PROD": self.authorize_prod, "DELPHI": self.authorize_delphi}[env]

        token = auth_method(auth_model)
        self.session.headers["Authorization"] = f"{token.token_type} {token.access_token}"
        self.session.headers["x-type"] = "mobile"
        self.session.headers["x-version"] = "1"
        self.session.headers["client-type"] = "autotests"
        self.session.headers["Cache-Mode"] = "ignore"
        return token.access_token

    def authorize_dev(self, auth_model=AuthData()):
        retries = Retry(total=10, backoff_factor=120, status_forcelist=[401, 429])
        self.session.mount("https://", HTTPAdapter(max_retries=retries))
        return AuthResponse(**self.session.post(CoreConfig.AUTH0_HOST, data=asdict(auth_model)).json())

    def authorize_prod(self, auth_model=None):
        auth_model_prod = AuthData(
            password=CoreConfig.USER_PASSWORD_PROD,
            client_id=CoreConfig.AUTH0_CLIENT_ID_PROD,
            client_secret=CoreConfig.AUTH0_CLIENT_SECRET_PROD,
            realm=CoreConfig.AUTH0_REALM_PROD,
            scope=CoreConfig.AUTH0_SCOPE_PROD,
        )
        return AuthResponse(**self.session.post(CoreConfig.AUTH0_HOST_PROD, data=asdict(auth_model_prod)).json())

    def authorize_delphi(self, auth_model=None):
        return AuthResponseDelphi(**self.session.post(CoreConfig.DELPHI_API_URL_PROD + "v3/oauth/token", data=asdict(AuthDataDelphi())).json())