import collections.abc

# imports
import pytest  # used for our unit tests
from src.datadog_api_client.v2.api.powerpack_api import PowerpackApi


# Mock models for testing
class PowerpackData(dict):
    """A mock PowerpackData class for testing."""
    def __init__(self, id, name):
        super().__init__(id=id, name=name)
        self.id = id
        self.name = name

class ListPowerpacksResponse(dict):
    """A mock ListPowerpacksResponse class for testing."""
    def __init__(self, data):
        super().__init__(data=data)
        self.data = data

# Mock Endpoint for testing
class MockEndpoint:
    def __init__(self, pages):
        """pages: list of ListPowerpacksResponse objects for each page."""
        self.pages = pages
        self.params_map = {
            "page_limit": {"openapi_types": (int,), "attribute": "page_limit", "location": "query"},
            "page_offset": {"openapi_types": (int,), "attribute": "page_offset", "location": "query"},
        }
        self.call_count = 0

    def gather_params(self, kwargs):
        # Simulate extracting params for pagination
        return {"path": {}, "query": {}, "header": {}, "body": None, "form": {}, "file": {}, "collection_format": {}}

    def call_with_http_info_paginated(self, pagination):
        # Simulate paginated API calls
        limit = pagination["limit_value"]
        offset = pagination["kwargs"].get("page_offset", 0)
        total_items = sum(len(page.data) for page in self.pages)
        # Calculate which page to start at
        items = []
        for page in self.pages:
            items.extend(page.data)
        paged_items = items[offset:offset+limit]
        # Only one call for simplicity
        yield from paged_items

# Patch PowerpackApi for testing
class TestPowerpackApi:
    def __init__(self, mock_endpoint):
        self._list_powerpacks_endpoint = mock_endpoint

    def list_powerpacks_with_pagination(
        self,
        *,
        page_limit: int = 25,
        page_offset: int = 0,
    ) -> collections.abc.Iterable[PowerpackData]:
        kwargs = {"page_limit": page_limit, "page_offset": page_offset}
        local_page_size = kwargs.get("page_limit", 25)
        endpoint = self._list_powerpacks_endpoint
        pagination = {
            "limit_value": local_page_size,
            "results_path": "data",
            "page_offset_param": "page_offset",
            "endpoint": endpoint,
            "kwargs": kwargs,
        }
        return endpoint.call_with_http_info_paginated(pagination)

# --- Unit Tests ---

# 1. Basic Test Cases






def test_non_integer_limit_and_offset():
    # Should raise TypeError if non-integer limit/offset
    data = [PowerpackData(str(i), f"name_{i}") for i in range(5)]
    pages = [ListPowerpacksResponse(data)]
    api = TestPowerpackApi(MockEndpoint(pages))
    with pytest.raises(TypeError):
        list(api.list_powerpacks_with_pagination(page_limit="ten"))
    with pytest.raises(TypeError):
        list(api.list_powerpacks_with_pagination(page_limit=2, page_offset="one"))

# 3. Large Scale Test Cases



#------------------------------------------------
import collections
from typing import List

# imports
import pytest  # used for our unit tests
from src.datadog_api_client.v2.api.powerpack_api import PowerpackApi


# Mocks for model classes
class PowerpackData:
    def __init__(self, id, name):
        self.id = id
        self.name = name

class ListPowerpacksResponse:
    def __init__(self, data: List[PowerpackData]):
        self.data = data

# Mock Endpoint and ApiClient for test isolation
class MockEndpoint:
    def __init__(self, responses, params_map=None):
        self.responses = responses  # List of ListPowerpacksResponse objects
        self.call_count = 0
        self.params_map = params_map or {
            "page_limit": {"openapi_types": (int,), "attribute": "page[limit]", "location": "query"},
            "page_offset": {"openapi_types": (int,), "attribute": "page[offset]", "location": "query"},
        }

    def call_with_http_info_paginated(self, pagination):
        # Simulate paginated API calls
        limit = pagination["limit_value"]
        offset = pagination["kwargs"].get("page_offset", 0)
        total_data = []
        for resp in self.responses:
            total_data.extend(resp.data)
        # Simulate paginated generator
        while offset < len(total_data):
            page = total_data[offset:offset + limit]
            yield from page
            if len(page) < limit:
                break
            offset += limit

# Function to test
def list_powerpacks_with_pagination(
    *,
    page_limit=25,
    page_offset=0,
    endpoint=None,
) -> collections.abc.Iterable[PowerpackData]:
    """
    Get all powerpacks, paginated.
    :param page_limit: Maximum number of powerpacks per page.
    :param page_offset: Offset for pagination.
    :param endpoint: Endpoint to use for API calls (injected for testing).
    :return: Iterable of PowerpackData.
    """
    if page_limit is None or page_limit <= 0:
        raise ValueError("page_limit must be a positive integer")
    if page_offset is None or page_offset < 0:
        raise ValueError("page_offset must be a non-negative integer")
    if endpoint is None:
        raise ValueError("endpoint must be provided for testing")
    kwargs = {"page_limit": page_limit, "page_offset": page_offset}
    pagination = {
        "limit_value": page_limit,
        "results_path": "data",
        "page_offset_param": "page_offset",
        "endpoint": endpoint,
        "kwargs": kwargs,
    }
    return endpoint.call_with_http_info_paginated(pagination)

# ------------------- UNIT TESTS -------------------

# Helper to create mock endpoint with N items, optionally paginated
def make_endpoint(num_items, page_limit=25):
    # Create PowerpackData objects
    items = [PowerpackData(str(i), f"Powerpack {i}") for i in range(num_items)]
    # Simulate paginated responses
    responses = []
    for offset in range(0, num_items, page_limit):
        responses.append(ListPowerpacksResponse(items[offset:offset + page_limit]))
    return MockEndpoint(responses)

# ----------- BASIC TEST CASES -----------






#------------------------------------------------
from src.datadog_api_client.v2.api.powerpack_api import PowerpackApi
import pytest

def test_PowerpackApi_list_powerpacks_with_pagination():
    with pytest.raises(AttributeError, match="'SymbolicInt'\\ object\\ has\\ no\\ attribute\\ 'configuration'"):
        PowerpackApi.list_powerpacks_with_pagination(PowerpackApi(api_client=0), page_limit=0, page_offset=0)