exceptions

class PixelBadRequestError(Exception):
    """Exception raised when a bad request is made to the Pixel API."""

    def __init__(
        self,
        response_json: dict,
        status_code: int,
        method: str,
        url: str,
        request_id: str | None = None,
        body: str | None = None,
    ):
        # Pretty print the response json
        self.json_resp_msg = json.dumps(response_json, indent=4)
        self.status_code = status_code
        self.method = method
        self.url = url
        self.body = body
        self.message = f"Bad request {self.status_code} for {self.method} {self.url} (request ID: {request_id})"
        if body:
            self.message += f"\nPayload:\n{self.body}"
        self.message += f"\nResponse: \n{self.json_resp_msg}"
        # Catch validation errors from pydantic
        super().__init__(self.message)

class PixelUploadJobError(Exception):
    """
    Exception raised when an upload job fails.
    """

    def __init__(self, job_id: int, status: str, detail: str):
        self.job_id = job_id
        self.detail = detail
        self.status = status
        message = (
            f"Upload job {job_id} failed with status '{status}', detail: \n{detail}"
        )
        super().__init__(message)

class PixelMultipleUploadJobError(Exception):
    """
    Exception raised when multiple upload jobs fail.
    """

    def __init__(self, errors: list[PixelUploadJobError]):
        self.errors = errors
        error_messages = "\n".join(str(e) for e in errors)
        message = f"Multiple upload jobs failed:\n{error_messages}"
        super().__init__(message)

class PixelAccessUpdateError(Exception):
    """
    Exception raised when an access change that spans several requests partly fails.

    Every independent request is attempted before this is raised, so
    `succeeded` lists the changes that were applied and `failed` the ones that
    were not, each with the error the API returned.

    Attributes:
        succeeded: The changes that were applied.
        failed: The changes that were not applied, paired with their error.
        result: The object created by the call (a user or group), if it got that far.
    """

    def __init__(
        self,
        succeeded: list[dict],
        failed: list[tuple[dict, Exception]],
        result: dict | None = None,
    ):
        self.succeeded = succeeded
        self.failed = failed
        self.result = result
        lines = [
            f"- {change.get('action', 'change')} {change.get('principal_kind', '')} "
            f"{change.get('principal_id', '')} on {change.get('resource', '')}: {error}"
            for change, error in failed
        ]
        message = (
            f"{len(failed)} access change(s) failed, {len(succeeded)} succeeded:\n"
            + "\n".join(lines)
        )
        super().__init__(message)