from http import HTTPStatus
from typing import Any, Dict, Optional, Union

import httpx

from ... import errors
from ...client import AuthenticatedClient, Client
from ...models.http_validation_error import HTTPValidationError
from ...models.log_request import LogRequest
from ...types import Response


def _get_kwargs(
    *,
    body: LogRequest,
) -> Dict[str, Any]:
    headers: Dict[str, Any] = {}

    _kwargs: Dict[str, Any] = {
        "method": "post",
        "url": "/log",
    }

    _body = body.to_dict()

    _kwargs["json"] = _body
    headers["Content-Type"] = "application/json"

    _kwargs["headers"] = headers
    return _kwargs


def _parse_response(
    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
) -> Optional[Union[Any, HTTPValidationError]]:
    if response.status_code == HTTPStatus.OK:
        response_200 = response.json()
        return response_200
    if response.status_code == HTTPStatus.UNPROCESSABLE_ENTITY:
        response_422 = HTTPValidationError.from_dict(response.json())

        return response_422
    if client.raise_on_unexpected_status:
        raise errors.UnexpectedStatus(response.status_code, response.content)
    else:
        return None


def _build_response(
    *, client: Union[AuthenticatedClient, Client], response: httpx.Response
) -> Response[Union[Any, HTTPValidationError]]:
    return Response(
        status_code=HTTPStatus(response.status_code),
        content=response.content,
        headers=response.headers,
        parsed=_parse_response(client=client, response=response),
    )


def sync_detailed(
    *,
    client: Union[AuthenticatedClient, Client],
    body: LogRequest,
) -> Response[Union[Any, HTTPValidationError]]:
    r"""Profile tabular data

     Profile tabular data. The Swagger UI isn't able to call this currently.

    ## Sample curl request:

    ```bash
    curl -X 'POST'         -H \"X-API-Key: <password>\"         -H \"Content-Type: application/json\"
    'http://localhost:8000/log'         --data-raw '{
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [ \"age\", \"workclass\", \"fnlwgt\", \"education\" ],
            \"data\": [
                [ 25, \"Private\", 226802, \"11th\" ]
            ]
        }
    }'
    ```
    ## Sample Python client request:
    ```python
    from whylogs_container_client import AuthenticatedClient
    import whylogs_container_client.api.profile.log as Log
    from whylogs_container_client.models import LogRequest, LogMultiple
    from datetime import datetime

    client = AuthenticatedClient(base_url=\"http://localhost:8000\", token=\"password\", prefix=\"\",
    auth_header_name=\"X-API-Key\")

    data = LogRequest(
        dataset_id=\"model-1\",
        timestamp=int(datetime.now().timestamp() * 1000),
        multiple=LogMultiple(
            columns=[\"col1\", \"col2\"],
            data=[[1, 2], [3, 4]],
        )
    )

    response = Log.sync_detailed(client=client, json_body=data)
    if response.status_code != 200:
        raise Exception(f\"Failed to log data. Status code: {response.status_code}\")
    # API is async, it won't fail and has no return body
    ```

    ## Sample Python request (using `requests`):
    ```python
    import requests

    # Define your API key
    api_key = \"<password>\"

    # API endpoint
    url = 'http://localhost:8000/log'

    # Sample data
    data = {
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [\"age\", \"workclass\", \"fnlwgt\", \"education\"],
            \"data\": [
                [25, \"Private\", 226802, \"11th\"]
            ]
        }
    }

    # Make the POST request
    headers = {\"X-API-Key\": api_key}
    response = requests.post(url, json=data, headers=headers)
    ```

    Args:
        body (LogRequest):

    Raises:
        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
        httpx.TimeoutException: If the request takes longer than Client.timeout.

    Returns:
        Response[Union[Any, HTTPValidationError]]
    """

    kwargs = _get_kwargs(
        body=body,
    )

    response = client.get_httpx_client().request(
        **kwargs,
    )

    return _build_response(client=client, response=response)


def sync(
    *,
    client: Union[AuthenticatedClient, Client],
    body: LogRequest,
) -> Optional[Union[Any, HTTPValidationError]]:
    r"""Profile tabular data

     Profile tabular data. The Swagger UI isn't able to call this currently.

    ## Sample curl request:

    ```bash
    curl -X 'POST'         -H \"X-API-Key: <password>\"         -H \"Content-Type: application/json\"
    'http://localhost:8000/log'         --data-raw '{
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [ \"age\", \"workclass\", \"fnlwgt\", \"education\" ],
            \"data\": [
                [ 25, \"Private\", 226802, \"11th\" ]
            ]
        }
    }'
    ```
    ## Sample Python client request:
    ```python
    from whylogs_container_client import AuthenticatedClient
    import whylogs_container_client.api.profile.log as Log
    from whylogs_container_client.models import LogRequest, LogMultiple
    from datetime import datetime

    client = AuthenticatedClient(base_url=\"http://localhost:8000\", token=\"password\", prefix=\"\",
    auth_header_name=\"X-API-Key\")

    data = LogRequest(
        dataset_id=\"model-1\",
        timestamp=int(datetime.now().timestamp() * 1000),
        multiple=LogMultiple(
            columns=[\"col1\", \"col2\"],
            data=[[1, 2], [3, 4]],
        )
    )

    response = Log.sync_detailed(client=client, json_body=data)
    if response.status_code != 200:
        raise Exception(f\"Failed to log data. Status code: {response.status_code}\")
    # API is async, it won't fail and has no return body
    ```

    ## Sample Python request (using `requests`):
    ```python
    import requests

    # Define your API key
    api_key = \"<password>\"

    # API endpoint
    url = 'http://localhost:8000/log'

    # Sample data
    data = {
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [\"age\", \"workclass\", \"fnlwgt\", \"education\"],
            \"data\": [
                [25, \"Private\", 226802, \"11th\"]
            ]
        }
    }

    # Make the POST request
    headers = {\"X-API-Key\": api_key}
    response = requests.post(url, json=data, headers=headers)
    ```

    Args:
        body (LogRequest):

    Raises:
        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
        httpx.TimeoutException: If the request takes longer than Client.timeout.

    Returns:
        Union[Any, HTTPValidationError]
    """

    return sync_detailed(
        client=client,
        body=body,
    ).parsed


async def asyncio_detailed(
    *,
    client: Union[AuthenticatedClient, Client],
    body: LogRequest,
) -> Response[Union[Any, HTTPValidationError]]:
    r"""Profile tabular data

     Profile tabular data. The Swagger UI isn't able to call this currently.

    ## Sample curl request:

    ```bash
    curl -X 'POST'         -H \"X-API-Key: <password>\"         -H \"Content-Type: application/json\"
    'http://localhost:8000/log'         --data-raw '{
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [ \"age\", \"workclass\", \"fnlwgt\", \"education\" ],
            \"data\": [
                [ 25, \"Private\", 226802, \"11th\" ]
            ]
        }
    }'
    ```
    ## Sample Python client request:
    ```python
    from whylogs_container_client import AuthenticatedClient
    import whylogs_container_client.api.profile.log as Log
    from whylogs_container_client.models import LogRequest, LogMultiple
    from datetime import datetime

    client = AuthenticatedClient(base_url=\"http://localhost:8000\", token=\"password\", prefix=\"\",
    auth_header_name=\"X-API-Key\")

    data = LogRequest(
        dataset_id=\"model-1\",
        timestamp=int(datetime.now().timestamp() * 1000),
        multiple=LogMultiple(
            columns=[\"col1\", \"col2\"],
            data=[[1, 2], [3, 4]],
        )
    )

    response = Log.sync_detailed(client=client, json_body=data)
    if response.status_code != 200:
        raise Exception(f\"Failed to log data. Status code: {response.status_code}\")
    # API is async, it won't fail and has no return body
    ```

    ## Sample Python request (using `requests`):
    ```python
    import requests

    # Define your API key
    api_key = \"<password>\"

    # API endpoint
    url = 'http://localhost:8000/log'

    # Sample data
    data = {
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [\"age\", \"workclass\", \"fnlwgt\", \"education\"],
            \"data\": [
                [25, \"Private\", 226802, \"11th\"]
            ]
        }
    }

    # Make the POST request
    headers = {\"X-API-Key\": api_key}
    response = requests.post(url, json=data, headers=headers)
    ```

    Args:
        body (LogRequest):

    Raises:
        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
        httpx.TimeoutException: If the request takes longer than Client.timeout.

    Returns:
        Response[Union[Any, HTTPValidationError]]
    """

    kwargs = _get_kwargs(
        body=body,
    )

    response = await client.get_async_httpx_client().request(**kwargs)

    return _build_response(client=client, response=response)


async def asyncio(
    *,
    client: Union[AuthenticatedClient, Client],
    body: LogRequest,
) -> Optional[Union[Any, HTTPValidationError]]:
    r"""Profile tabular data

     Profile tabular data. The Swagger UI isn't able to call this currently.

    ## Sample curl request:

    ```bash
    curl -X 'POST'         -H \"X-API-Key: <password>\"         -H \"Content-Type: application/json\"
    'http://localhost:8000/log'         --data-raw '{
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [ \"age\", \"workclass\", \"fnlwgt\", \"education\" ],
            \"data\": [
                [ 25, \"Private\", 226802, \"11th\" ]
            ]
        }
    }'
    ```
    ## Sample Python client request:
    ```python
    from whylogs_container_client import AuthenticatedClient
    import whylogs_container_client.api.profile.log as Log
    from whylogs_container_client.models import LogRequest, LogMultiple
    from datetime import datetime

    client = AuthenticatedClient(base_url=\"http://localhost:8000\", token=\"password\", prefix=\"\",
    auth_header_name=\"X-API-Key\")

    data = LogRequest(
        dataset_id=\"model-1\",
        timestamp=int(datetime.now().timestamp() * 1000),
        multiple=LogMultiple(
            columns=[\"col1\", \"col2\"],
            data=[[1, 2], [3, 4]],
        )
    )

    response = Log.sync_detailed(client=client, json_body=data)
    if response.status_code != 200:
        raise Exception(f\"Failed to log data. Status code: {response.status_code}\")
    # API is async, it won't fail and has no return body
    ```

    ## Sample Python request (using `requests`):
    ```python
    import requests

    # Define your API key
    api_key = \"<password>\"

    # API endpoint
    url = 'http://localhost:8000/log'

    # Sample data
    data = {
        \"datasetId\": \"model-62\",
        \"multiple\": {
            \"columns\": [\"age\", \"workclass\", \"fnlwgt\", \"education\"],
            \"data\": [
                [25, \"Private\", 226802, \"11th\"]
            ]
        }
    }

    # Make the POST request
    headers = {\"X-API-Key\": api_key}
    response = requests.post(url, json=data, headers=headers)
    ```

    Args:
        body (LogRequest):

    Raises:
        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
        httpx.TimeoutException: If the request takes longer than Client.timeout.

    Returns:
        Union[Any, HTTPValidationError]
    """

    return (
        await asyncio_detailed(
            client=client,
            body=body,
        )
    ).parsed
