import time

import requests
from django.conf import settings
from django.core.cache import cache
from django.db import models
from httpx import Request

from utils.clients.gooyal_accounts_client import AuthenticatedClient
from utils.clients.gooyal_accounts_client.models import Account
from utils.clients.gooyal_accounts_client.api.users import (users_api_users_details_retrieve)
from utils.http_fallback import request_with_ssl_fallback, resolve_verify_ssl



def login_as_client_credentials():
    access_token = cache.get('settlement_access_token')
    # expires_in = self.auth_data.get('expires_in')
    # created_at = self.auth_data.get('created_at')
    #
    # if access_token and expires_in > time.time() - created_at:
    #     return self.auth_data
    if access_token:
        print('already in cache')
        return access_token

    print('not in cache')

    data = {
        "grant_type": 'client_credentials',
        "scope": settings.OAUTH2_PROVIDER_SCOPES,
    }
    auth = (settings.OAUTH2_PROVIDER_CLIENT_ID, settings.OAUTH2_PROVIDER_CLIENT_SECRET)

    response = request_with_ssl_fallback('POST', f'{settings.OAUTH2_PROVIDER_BASE_PUBLIC_URL}/token/',
                             data=data,
                             auth=auth)
    print(response.content)

    auth_data = response.json()
    if 'access_token' in auth_data:
        auth_data['created_at'] = time.time()
        cache.set('settlement_access_token', auth_data, timeout=auth_data.get('expires_in') - 5)

    return auth_data


def log_request(request: Request):
    print(request.headers['authorization'])
    print(
        f"Request event hook: {request.method} {request.url} {request.method} {request.headers} - Waiting for response")


def log_response(response):
    request = response.request
    print(f"Response event hook: {request.method} {request.url} - Status {response.status_code}")


def get_client():
    access_token = login_as_client_credentials()['access_token']
    verify_ssl = resolve_verify_ssl(settings.ACCOUNTS_BASE_PUBLIC_URL)
    client = AuthenticatedClient(base_url=settings.ACCOUNTS_BASE_PUBLIC_URL, token=access_token,
                                 verify_ssl=verify_ssl,
                                 httpx_args={"event_hooks": {"request": [log_request], "response": [log_response]}},
                                 )
    return client


def get_user_detailed_info(uuid):
    client = get_client()
    response: Account = users_api_users_details_retrieve.sync(uuid=uuid, client=client)
    print(response)

    return response


def list_users(limit=100, offset=0):
    """Fetch one page of the accounts user list.

    The generated OpenAPI client (users_api_users_list) only supports
    `page`, and that param is silently ignored by the upstream endpoint --
    every page returns the same first results. Its real pagination is
    limit/offset, so this bypasses the generated wrapper with a raw request.
    """
    access_token = login_as_client_credentials()['access_token']
    base_url = settings.ACCOUNTS_BASE_PUBLIC_URL
    url = f"{base_url.rstrip('/')}/users/api/users/"

    response = request_with_ssl_fallback(
        'GET',
        url,
        params={"limit": limit, "offset": offset},
        headers={"Authorization": f"Bearer {access_token}"},
        verify=resolve_verify_ssl(base_url),
    )
    response.raise_for_status()
    return response.json()