Drawing

@staticmethod
def from_argb(
    argb: Optional[int] = None,
    alpha: Optional[int] = None,
    base_color: Optional[ColorData] = None,
    red: Optional[int] = None,
    green: Optional[int] = None,
    blue: Optional[int] = None,
) -> ColorData:
    """
    Creates a ColorData object from various input formats matching C# System.Drawing.Color

    :param argb: A value specifying the 32-bit ARGB value, defaults to None
    :param alpha: The alpha component. Valid values are 0 through 255, defaults to None
    :param base_color: The System.Drawing.Color from which to create the new System.Drawing.Color, defaults to None
    :param red: The red component. Valid values are 0 through 255, defaults to None
    :param green: The green component. Valid values are 0 through 255, defaults to None
    :param blue: The blue component. Valid values are 0 through 255, defaults to None
    :raises ValueError: On invalid input combination
    :return: The ColorData object representing the color.
    """

    # Check for valid input combinations
    if all(
        x is not None for x in [alpha, red, green, blue]
    ):  # Check if all components are provided (including None)
        # ARGB with all components provided
        return ColorData(cs_object=CSColor.FromArgb(alpha, red, green, blue))
    elif all(x is not None for x in [red, green, blue]) and alpha is None:
        # RGB with implicit alpha 255
        return ColorData(cs_object=CSColor.FromArgb(red, green, blue))
    elif alpha is not None and base_color is not None:
        # Set alpha for existing color
        return ColorData(cs_object=CSColor.FromArgb(alpha, base_color.cs_object))
    elif argb is not None and any([alpha, red, green, blue]) is False:
        # Single ARGB value
        alpha = (argb >> 24) & 0xFF  # Extract alpha (shift 24 bits and mask with 0xFF)
        red = (argb >> 16) & 0xFF  # Extract red (shift 16 bits and mask with 0xFF)
        green = (argb >> 8) & 0xFF  # Extract green (shift 8 bits and mask with 0xFF)
        blue = argb & 0xFF  # Extract blue (mask with 0xFF)
        return ColorData(cs_object=CSColor.FromArgb(alpha, red, green, blue))
    else:
        raise ValueError("Invalid arguments sent as input, cannot create ColorData object.")

@staticmethod
def from_known_color(known_color: KnownColor) -> ColorData:
    """Creates a System.Drawing.Color structure from the specified predefined color.

    :param known_color: An element of the System.Drawing.KnownColor enumeration.
    :return: The System.Drawing.Color that this method creates.
    """
    return ColorData(cs_object=CSColor.FromKnownColor(known_color.value))

@staticmethod
def from_name(name: str) -> ColorData:
    """Creates a System.Drawing.Color structure from the specified name of a predefined
    color.

    :param name: A string that is the name of a predefined color. Valid names are the same as
    the names of the elements of the System.Drawing.KnownColor enumeration.
    :return: The System.Drawing.Color that this method creates.
    """
    return ColorData(cs_object=CSColor.FromName(name))

def equals(self, another_color: ColorData) -> bool:
    """Indicates whether the current object is equal to another object of the same type.

    :param another_color: An object to compare with this object.
    :return: True if the current object is equal to other; otherwise, False.
    """
    return self.cs_object.Equals(another_color.cs_object)

def get_brightness(self) -> float:
    """Gets the hue-saturation-lightness (HSL) lightness value for this System.Drawing.Color
    structure.

    :return: The lightness of this System.Drawing.Color. The lightness ranges from 0.0 through
    1.0, where 0.0 represents black and 1.0 represents white.
    """
    return self.cs_object.GetBrightness()

def get_hash_code(self) -> int:
    """Returns a hash code for this System.Drawing.Color structure.

    :return: An integer value that specifies the hash code for this System.Drawing.Color.
    """
    return self.cs_object.GetHashCode()

def get_hue(self) -> float:
    """Gets the hue-saturation-lightness (HSL) hue value, in degrees, for this System.Drawing.Color
    structure.

    :return: The hue, in degrees, of this System.Drawing.Color. The hue is measured in degrees,
    ranging from 0.0 through 360.0, in HSL color space.
    """
    return self.cs_object.GetHashCode()

def get_saturation(self) -> float:
    """Gets the hue-saturation-lightness (HSL) saturation value for this System.Drawing.Color
    structure.

    :return: The saturation of this System.Drawing.Color. The saturation ranges from 0.0 through
    1.0, where 0.0 is grayscale and 1.0 is the most saturated.
    """
    return self.cs_object.GetSaturation()

def to_argb(self) -> int:
    """Gets the 32-bit ARGB value of this System.Drawing.Color structure.

    :return: The 32-bit ARGB value of this System.Drawing.Color.
    """
    return self.cs_object.ToArgb()

def to_known_color(self) -> KnownColor:
    """Gets the System.Drawing.KnownColor value of this System.Drawing.Color structure.

    :return: An element of the System.Drawing.KnownColor enumeration, if the System.Drawing.Color
    is created from a predefined color by using either the System.Drawing.Color.FromName(System.String)
    method or the System.Drawing.Color.FromKnownColor(System.Drawing.KnownColor)
    method; otherwise, 0.
    """
    return KnownColor(self.cs_object.ToKnownColor())

def to_string(self) -> int:
    """Converts this System.Drawing.Color structure to a human-readable string.

    :return: A string that is the name of this System.Drawing.Color, if the System.Drawing.Color
    is created from a predefined color by using either the System.Drawing.Color.FromName(System.String)
    method or the System.Drawing.Color.FromKnownColor(System.Drawing.KnownColor)
    method; otherwise, a string that consists of the ARGB component names and their
    values.
    """
    return self.cs_object.ToString()

def __add__(self, other: Size) -> Point:
    """Translates a point by a given Size

    :param other: Size object to add
    :return: A new Point object with the translated coordinates
    """
    if isinstance(other, Size):
        return Point(raw_value=self.raw_value.Add(self.raw_value, other.raw_value))  # type: ignore
    else:
        raise TypeError(f"Unsupported operand type(s) for +: 'Point' and '{type(other)}'")

def __eq__(self, other: object) -> bool:
    """Compares two Point objects for equality

    Accepts any object (matches BaseModel signature) and returns False when the
    other object is not a Point.
    """
    if not isinstance(other, Point):
        return False

    return self.x == other.x and self.y == other.y

def __ne__(self, other: object) -> bool:
    """Compares two Point objects for inequality

    Accepts any object (matches BaseModel signature).
    """
    return not self == other

def __sub__(self, other: Size) -> Point:
    """Translates the Point by the negative of the specified Size.

    :param other: Size object to subtract
    :return: A new Point object with the translated coordinates
    """
    if not isinstance(other, Size):
        raise TypeError(f"Unsupported operand type(s) for +: 'Point' and '{type(other)}'")

    return Point(raw_value=(self.x - other.width, self.y - other.height))  # type: ignore

def add(self, point: Point, size: Size) -> Point:
    """Adds the specified Size tot he specified Point

    :param point: The point to add
    :param size: The size to add
    :return: The point that is the result of the addition operation
    """
    return Point(raw_value=self.raw_value.Add(point.raw_value, size.raw_value))  # type: ignore

def distance(
    self, other_x: Optional[int] = None, other_y: Optional[int] = None, other_point: Optional[Point] = None
) -> float:
    """Calculates the distance between two points or the distance between a point and an x/y coordinate pair.

    This is similar to Distance method listed in FlaUI.Core.Tools.ExtensionMethods.

    :param other_x: The x-coordinate of the second point., defaults to None
    :param other_y: The y-coordinate of the second point., defaults to None
    :param other_point: The second point, defaults to None
    :return: Distance calculated
    """
    if other_x is not None and other_y is not None:
        return sqrt((pow(self.x - other_x, 2) + pow(self.y - other_y, 2)))
    elif other_point is not None:
        return sqrt((pow(self.x - other_point.x, 2) + pow(self.y - other_point.y, 2)))
    else:
        raise ValueError(
            "Invalid arguments passed to measure distance, you need to pass x-coordinate & y-coordinate or Point object"
        )

def equals(self, other: Point) -> bool:
    """Specifies whether this point instance contains the same coordinates as another point.

    :param other: Value to compare
    :return: True if equal, else False
    """
    return self.raw_value.Equals(other.raw_value)  # type: ignore

def get_hash_code(self) -> int:
    """Returns a hash code for this Point.

    :return: An integer value that specifies the hash code for this Point.
    """
    return self.raw_value.GetHashCode()  # type: ignore

def offset(self, x: Optional[int] = None, y: Optional[int] = None, point: Optional[Point] = None) -> None:
    """Translates this Point by the specified amount/specified Point

    :param x: x-coordinate, defaults to None
    :param y: y-coordinate, defaults to None
    :param point: Point object, defaults to None
    """
    self.raw_value.Offset(x, y) if point is None else self.raw_value.Offset(point.raw_value)  # type: ignore

@field_validator("raw_value")
@classmethod
def parse_cs_object(cls, v: Union[int, Tuple[int, int], Tuple[float, float], CSPoint, Size]) -> CSPoint:
    """Parses C# Point object from System.Drawing namespace

    :param v: Input value
    :return: Parsed C# object
    """
    if isinstance(v, CSPoint):
        # Always create a new Point object to avoid shared mutable state
        return CSPoint(v.X, v.Y)  # pyright: ignore[reportAttributeAccessIssue]
    if isinstance(v, Size):
        return CSPoint(v.raw_value)

    return CSPoint(v) if isinstance(v, int) else CSPoint(round(v[0]), round(v[1]))

def subtract(self, point: Point, size: Size) -> Point:
    """Returns the result of subtracting specified Size from the specified Point.

    :param point: Point object
    :param size: Size object
    :return: Subtracted Point object
    """
    return Point(raw_value=self.raw_value.Subtract(point.raw_value, size.raw_value))  # type: ignore

def to_size(self) -> Size:
    """Explicitly converts the specified Point structure to Size structure

    :return: Size object
    """
    return Size(raw_value=(self.x, self.y))

def to_string(self) -> str:
    """Converts this Point to a human-readable string.

    :return: Point as readable string.
    """
    return self.raw_value.ToString()  # type: ignore

def __eq__(self, other: object) -> bool:
    """Tests whether two Rectangle structures have equal location and size.

    Accepts any object (matches BaseModel signature) and returns False when the
    other object is not a Rectangle.
    """
    if not isinstance(other, Rectangle):
        return False

    return self.left == other.left and self.right == other.right

def __ne__(self, other: object) -> bool:
    """Compares two Rectangle objects for inequality

    Accepts any object (matches BaseModel signature).
    """
    return not self == other

def center(self) -> Point:
    """Returns center of this rectangle as a Point object

    :return: Point object
    """
    return Point(raw_value=(self.width / 2 + self.left, self.height / 2 + self.top))

def contains(self, other: Union[Tuple[int, int], Point]) -> bool:
    """Determines if the specified point is contained within this Rectangle structure.

    :param other: Value to compare
    :return: True if it contains, else False
    """
    return (
        self.raw_value.Contains(other.raw_value)  # type: ignore
        if (isinstance(other, Point) or isinstance(other, Rectangle))
        else self.raw_value.Contains(other[0], other[1])  # type: ignore
    )

def east(self, by: int = 0) -> Point:
    """Returns East of the rectangle as a Point object

    :param by: Move by, defaults to 0
    :return: Point object
    """
    return Point(raw_value=(self.right + by, self.center().y))

def equals(self, other: Rectangle) -> bool:
    """Specifies whether this Rectangle instance contains the same coordinates as another point.

    :param other: Value to compare
    :return: True if equal, else False
    """
    return self.raw_value.Equals(other.raw_value)  # type: ignore

def from_ltrb(self, value: List[int]) -> Rectangle:
    """Creates a Rectangle structure with the specified edge locations.

    :param value: Value to set
    :return: Rectangle object
    """
    if not len(value) == 4:
        raise ValueError(
            f"The input values have to be a list of 4 integers to create a Rectangle structure, current input - {value}"
        )

    return Rectangle(raw_value=self.raw_value.FromLTRB(*value))  # type: ignore

def get_hash_code(self) -> int:
    """Returns a hash code for this Rectangle.

    :return: An integer value that specifies the hash code for this Rectangle.
    """
    return self.raw_value.GetHashCode()  # type: ignore

def immediate_exterior_east(self) -> Point:
    """Returns immediate exterior East

    :return: Point object
    """
    return self.east(1)

def immediate_exterior_north(self) -> Point:
    """Returns immediate exterior North

    :return: Point object
    """
    return self.north(-1)

def immediate_exterior_south(self) -> Point:
    """Returns immediate exterior South

    :return: Point object
    """
    return self.south(1)

def immediate_exterior_west(self) -> Point:
    """Returns immediate exterior West

    :return: Point object
    """
    return self.west(-1)

def immediate_interior_east(self) -> Point:
    """Returns immediate interior East

    :return: Point object
    """
    return self.east(-1)

def immediate_interior_north(self) -> Point:
    """Returns immediate interior North

    :return: Point object
    """
    return self.north(1)

def immediate_interior_south(self) -> Point:
    """Returns immediate interior South

    :return: Point object
    """
    return self.south(-1)

def immediate_interior_west(self) -> Point:
    """Returns immediate interior West

    :return: Point object
    """
    return self.west(1)

def inflate(self, value: Tuple[int, int]) -> Rectangle:
    """Enlarges this Rectangle by the specified amount.

    :param value: Value to enlarge
    :return: Enlarged Rectangle
    """
    # ``Rectangle.Inflate(int, int)`` is the void *instance* overload that mutates in place;
    # use the static ``Rectangle.Inflate(rect, x, y)`` overload to return a new Rectangle.
    return Rectangle(raw_value=CSRectangle.Inflate(self.raw_value, value[0], value[1]))  # type: ignore

def intersects_with(self, other: Rectangle) -> bool:
    """Determines if this rectangle intersects with rect.

    :param other: Value to check
    :return: True if there is any intersection, otherwise False
    """
    return self.raw_value.IntersectsWith(other.raw_value)  # type: ignore

def interset(self, other: Union[Rectangle, Tuple[Rectangle, Rectangle]]) -> Rectangle:
    """Replaces this Rectangle with the intersection of itself and the specified Rectangle.
    Returns a third Rectangle structure that represents the intersection of two other Rectangle structures. If there is no intersection, an empty Rectangle is returned.

    :param other: Value to intersect with
    :return: Updated rectangle
    """
    # The single-argument instance ``Intersect(Rectangle)`` overload mutates in place and
    # returns void; use the static ``Rectangle.Intersect(a, b)`` overload, which returns the
    # intersection (an empty Rectangle when the two do not overlap).
    return Rectangle(
        raw_value=CSRectangle.Intersect(self.raw_value, other.raw_value)  # type: ignore
        if isinstance(other, Rectangle)
        else CSRectangle.Intersect(*[_.raw_value for _ in other])  # type: ignore
    )

def make_even(self) -> Rectangle:
    """
    Makes the width and height of a rectangle a multiple of 2, if not already.

    This is a direct coversion of Even method listed in FlaUI.Core.Tools.ExtensionMethods class.

    :return: A new Rectangle object with even dimensions (optional), or None if the input rectangle is None.
    """
    # In-place modification (if possible)
    try:
        if self.width % 2 == 1:
            self.width -= 1
        if self.height % 2 == 1:
            self.height -= 1

    except AttributeError:  # Handle cases where width/height are not modifiable
        raise ValueError("Something went wrong modifying width/height for the rectangle making it even.")
    else:
        # Create a new self if in-place modification is not possible
        return Rectangle(raw_value=self.raw_value)

def north(self, by: int = 0) -> Point:
    """Returns North of the rectangle as a Point object

    :param by: Move by, defaults to 0
    :return: Point object
    """
    return Point(raw_value=(self.center().x, self.top + by))

def offset(self, x: Optional[int] = None, y: Optional[int] = None, point: Optional[Point] = None) -> None:
    """Adjusts the location of this rectangle by the specified amount.

    :param x: x-coordinate, defaults to None
    :param y: y-coordinate, defaults to None
    :param point: Point object, defaults to None
    """
    self.raw_value.Offset(x, y) if point is None else self.raw_value.Offset(point.raw_value)  # type: ignore

@field_validator("raw_value")
@classmethod
def parse_cs_object(cls, v: Union[List[int], Tuple[Point, Size], CSRectangle]) -> CSPoint:
    """Parses C# Rectangle object from System.Drawing namespace

    :param v: Input value
    :return: Parsed C# object
    """
    if isinstance(v, CSRectangle):
        return v
    if isinstance(v, List) and len(v) == 4:
        return CSRectangle(*v)
    elif (isinstance(v, List) or isinstance(v, Tuple)) and (
        len(v) == 2 and isinstance(v[0], Point) and isinstance(v[1], Size)
    ):
        return CSRectangle(v[0].raw_value, v[1].raw_value)

    raise ValueError(f"Unable to parse input value to Rectable C# object, invalid input - {v}")

def south(self, by: int = 0) -> Point:
    """Returns South of the rectangle as a Point object

    :param by: Move by, defaults to 0
    :return: Point object
    """
    return Point(raw_value=(self.center().x, self.bottom + by))

def to_string(self) -> str:
    """Converts the attributes of this Rectangle to a human-readable string.

    :return: Point as readable string.
    """
    return self.raw_value.ToString()  # type: ignore

def union(self, others: Tuple[Rectangle, Rectangle]) -> Rectangle:
    """Gets a Rectangle structure that contains the union of two Rectangle structures.

    :param others: Tuple of rectangles to compare
    :return: A Rectangle structure that bounds the union of the two Rectangle structures.
    """
    return Rectangle(raw_value=self.raw_value.Union(*[_.raw_value for _ in others]))  # type: ignore

def west(self, by: int = 0) -> Point:
    """Returns West of the rectangle as a Point object

    :param by: Move by, defaults to 0
    :return: Point object
    """
    return Point(raw_value=(self.left + by, self.center().y))

def __add__(self, other: CSSize) -> Size:
    """Translates a size by a given Size

    :param other: Size object to add
    :return: A new Size object with the translated coordinates
    """
    if not isinstance(other, CSSize):
        raise TypeError(f"Unsupported operand type(s) for +: 'Size' and '{type(other)}'")

    return Size(raw_value=self.raw_value.Add(self.raw_value, other))  # type: ignore

def __eq__(self, other: object) -> bool:
    """Compares two Size objects for equality

    Accepts any object (matches BaseModel signature) and returns False when the
    other object is not a Size.
    """
    if not isinstance(other, Size):
        return False

    return self.width == other.width and self.height == other.height

def __ne__(self, other: object) -> bool:
    """Compares two Size objects for inequality

    Accepts any object (matches BaseModel signature).
    """
    return not self == other

def __sub__(self, other: CSSize) -> Size:
    """Translates the Size by the negative of the specified Size.

    :param other: Size object to subtract
    :return: A new Size object with the translated coordinates
    """
    if not isinstance(other, CSSize):
        raise TypeError(f"Unsupported operand type(s) for +: 'Size' and '{type(other)}'")

    return Size(raw_value=(self.width - other.Width, self.height - other.Height))  # type: ignore

def add(self, other: Size) -> Size:
    """Adds the specified Size tot he specified Size

    :param other: The size to add
    :return: The size that is the result of the addition operation
    """
    return Size(raw_value=self.raw_value.Add(self.raw_value, other.raw_value))  # type: ignore

def equals(self, other: Size) -> bool:
    """Specifies whether this size instance contains the same coordinates as another size.

    :param other: Value to compare
    :return: True if equal, else False
    """
    return self.raw_value.Equals(other.raw_value)  # type: ignore

def get_hash_code(self) -> int:
    """Returns a hash code for this Size.

    :return: An integer value that specifies the hash code for this Size.
    """
    return self.raw_value.GetHashCode()  # type: ignore