import os
import socket
import time
import traceback

if os.name == 'nt':
    import vgamepad as vg


class PS4_Buttons:
    def __init__(self):
        self.gamepad = vg.VDS4Gamepad()
        self.gamepad.update()
        time.sleep(0.1)

    def __del__(self):
        self.gamepad.__del__()

    def reset_to_default(self):
        self.gamepad.reset()
        self.gamepad.update()
        time.sleep(.4)

    def press_l2_r2(self, button, sleep_after=.4):
        self.gamepad.press_button(button)  # value between 0 and 255
        if button == vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT:
            self.gamepad.right_trigger(value=255)
        else:
            self.gamepad.left_trigger(value=255)
        self.gamepad.update()
        time.sleep(sleep_after)

    def release_l2_r2(self, button, sleep_after=.2):
        self.gamepad.release_button(button)  # value between 0 and 255
        if button == vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT:
            self.gamepad.right_trigger(value=0)
        else:
            self.gamepad.left_trigger(value=0)
        self.gamepad.update()
        time.sleep(sleep_after)

    def press_and_release_l2_r2(self, button):
        self.press_l2_r2(button)
        self.release_l2_r2(button)

    def press_r2(self, sleep_after=.4):
        self.press_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT, sleep_after=sleep_after)

    def release_r2(self, sleep_after=.2):
        self.release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT, sleep_after=sleep_after)

    def r2(self):
        self.press_and_release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT)

    def press_l2(self):
        self.press_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_LEFT)

    def release_l2(self):
        self.release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_LEFT)

    def l2(self):
        self.press_and_release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_LEFT)

    def press_left_joystick(self, x, y, sleep_after=.4):
        self.gamepad.left_joystick(x, y)
        self.gamepad.update()
        time.sleep(sleep_after)

    def release_left_joystick(self):
        self.gamepad.left_joystick(128, 128)
        self.gamepad.update()
        time.sleep(0.2)

    def press_and_release_left_joystick(self, x, y):
        self.press_left_joystick(x, y)
        self.release_left_joystick()

    def press_left_joystick_float(self, x, y, press_time=.4):
        self.gamepad.left_joystick_float(x, y)
        self.gamepad.update()
        time.sleep(press_time)

    def release_left_joystick_float(self):
        self.gamepad.left_joystick_float(128, 128)
        self.gamepad.update()
        time.sleep(0.2)

    def press_and_release_left_joystick_float(self, x, y):
        self.press_left_joystick_float(x, y)
        self.release_left_joystick_float()

    def press_right_joystick(self, x, y):
        self.gamepad.right_joystick(x, y)
        self.gamepad.update()
        time.sleep(0.2)

    def release_right_joystick(self):
        self.gamepad.right_joystick(128, 128)
        self.gamepad.update()
        time.sleep(0.2)

    def press_and_release_right_joystick(self, x, y):
        self.press_right_joystick(x, y)
        self.release_right_joystick()

    def press_normal_button(self, button, press_time=0.4):
        self.gamepad.press_button(button=button)
        self.gamepad.update()
        time.sleep(press_time)

    def release_normal_button(self, button, sleep_after=0.2):
        self.gamepad.release_button(button=button)
        self.gamepad.update()
        time.sleep(sleep_after)

    def press_and_release_normal_buttons(self, button, press_time=0.4, sleep_after=0.2):
        self.press_normal_button(button, press_time=press_time)
        self.release_normal_button(button, sleep_after=sleep_after)

    def press_direction_button(self, button):
        self.gamepad.directional_pad(button)
        self.gamepad.update()
        time.sleep(0.4)

    def release_direction_button(self):
        self.gamepad.directional_pad(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_NONE)
        self.gamepad.update()
        time.sleep(0.1)

    def press_and_release_directions(self, button):
        self.press_direction_button(button)
        self.release_direction_button()

    def press_special_button(self, button):
        self.gamepad.press_special_button(special_button=button)
        self.gamepad.update()
        time.sleep(0.4)

    def release_special_button(self, button):
        self.gamepad.release_special_button(special_button=button)
        self.gamepad.update()
        time.sleep(0.2)

    def press_and_release_special_buttons(self, button):
        self.press_special_button(button)
        self.release_special_button(button)

    def press_l1(self):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_SHOULDER_LEFT)

    def release_l1(self):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_SHOULDER_LEFT)

    def l1(self, press_time=0.4, sleep_after=0.4):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_SHOULDER_LEFT,
                                              press_time=press_time, sleep_after=sleep_after)

    def press_r1(self, press_time=0.2):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_SHOULDER_RIGHT, press_time=press_time)

    def release_r1(self, sleep_after=0.2):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_SHOULDER_RIGHT, sleep_after=sleep_after)

    def r1(self):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_SHOULDER_RIGHT)

    def press_option(self):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_OPTIONS)

    def release_option(self):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_OPTIONS)

    def option(self):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_OPTIONS)

    def press_cross(self, press_time=0.4):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_CROSS, press_time=press_time)

    def release_cross(self, sleep_after=0.2):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_CROSS, sleep_after=sleep_after)

    def cross(self, press_time=0.2, sleep_after=0.4):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_CROSS,
                                              press_time=press_time, sleep_after=sleep_after)

    def press_circle(self):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_CIRCLE)

    def release_circle(self):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_CIRCLE)

    def circle(self, press_time=0.4):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_CIRCLE, press_time=press_time)

    def press_triangle(self):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIANGLE)

    def release_triangle(self):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIANGLE)

    def triangle(self):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIANGLE)

    def press_square(self):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_SQUARE)

    def release_square(self):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_SQUARE)

    def square(self):
        self.press_and_release_normal_buttons(vg.DS4_BUTTONS.DS4_BUTTON_SQUARE)

    def press_right(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_EAST)

    def release_right(self):
        self.release_direction_button()

    def right(self, sleep_after=0):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_EAST)
        if sleep_after:
            time.sleep(sleep_after)

    def press_left(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_WEST)

    def release_left(self):
        self.release_direction_button()

    def left(self, sleep_after=0):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_WEST)
        if sleep_after:
            time.sleep(sleep_after)

    def press_up(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_NORTH)

    def release_up(self):
        self.release_direction_button()

    def up(self, sleep_after=0):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_NORTH)
        if sleep_after:
            time.sleep(sleep_after)

    def press_down(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_SOUTH)

    def release_down(self):
        self.release_direction_button()

    def down(self, sleep_after=0):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_SOUTH)
        if sleep_after:
            time.sleep(sleep_after)

    def press_upright(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_NORTHEAST)

    def release_upright(self):
        self.release_direction_button()

    def upright(self):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_NORTHEAST)

    def press_upleft(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_NORTHWEST)

    def release_upleft(self):
        self.release_direction_button()

    def upleft(self):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_NORTHWEST)

    def press_downright(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_SOUTHEAST)

    def release_downright(self):
        self.release_direction_button()

    def downright(self):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_SOUTHEAST)

    def press_downleft(self):
        self.press_direction_button(button=vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_SOUTHWEST)

    def release_downleft(self):
        self.release_direction_button()

    def downleft(self):
        self.press_and_release_directions(vg.DS4_DPAD_DIRECTIONS.DS4_BUTTON_DPAD_SOUTHWEST)

    def press_ps(self):
        self.press_special_button(button=vg.DS4_SPECIAL_BUTTONS.DS4_SPECIAL_BUTTON_PS)

    def release_ps(self):
        self.release_special_button(button=vg.DS4_SPECIAL_BUTTONS.DS4_SPECIAL_BUTTON_PS)

    def ps(self):
        self.press_and_release_special_buttons(button=vg.DS4_SPECIAL_BUTTONS.DS4_SPECIAL_BUTTON_PS)

    def press_r3(self):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_THUMB_RIGHT)

    def release_r3(self):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_THUMB_RIGHT)

    def r3(self):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_THUMB_RIGHT)

    def press_l3(self):
        self.press_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_THUMB_LEFT)

    def release_l3(self):
        self.release_normal_button(button=vg.DS4_BUTTONS.DS4_BUTTON_THUMB_LEFT)

    def l3(self):
        self.press_and_release_normal_buttons(button=vg.DS4_BUTTONS.DS4_BUTTON_THUMB_LEFT)


class XBOXS_Buttons:
    def __init__(self):
        self.gamepad = vg.VX360Gamepad()
        self.gamepad.update()
        time.sleep(0.1)

    def __del__(self):
        self.gamepad.__del__()

    def reset_to_default(self):
        self.gamepad.reset()
        self.gamepad.update()
        time.sleep(.1)

    def press_l2_r2(self, button, sleep_after=.2):
        # self.gamepad.press_button(button)  # value between 0 and 255
        if button == vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT:
            self.gamepad.right_trigger(value=255)
        else:
            self.gamepad.left_trigger(value=255)
        self.gamepad.update()
        time.sleep(sleep_after)

    def release_l2_r2(self, button, sleep_after=.2):
        # self.gamepad.release_button(button)  # value between 0 and 255
        if button == vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT:
            self.gamepad.right_trigger(value=0)
        else:
            self.gamepad.left_trigger(value=0)
        self.gamepad.update()
        time.sleep(sleep_after)

    def press_and_release_l2_r2(self, button):
        self.press_l2_r2(button)
        self.release_l2_r2(button)

    def press_r2(self, sleep_after=.2):
        self.press_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT, sleep_after=sleep_after)

    def release_r2(self, sleep_after=.2):
        self.release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT, sleep_after=sleep_after)

    def r2(self):
        self.press_and_release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_RIGHT)

    def press_l2(self):
        self.press_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_LEFT)

    def release_l2(self):
        self.release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_LEFT)

    def l2(self):
        self.press_and_release_l2_r2(button=vg.DS4_BUTTONS.DS4_BUTTON_TRIGGER_LEFT)

    def press_left_joystick(self, x, y, sleep_after=.2):
        self.gamepad.left_joystick(x, y)
        self.gamepad.update()
        time.sleep(sleep_after)

    def release_left_joystick(self):
        self.gamepad.left_joystick(0, 0)
        self.gamepad.update()
        time.sleep(0.2)

    def press_and_release_left_joystick(self, x, y):
        self.press_left_joystick(x, y)
        self.release_left_joystick()

    def press_left_joystick_float(self, x, y, press_time=.2):
        self.gamepad.left_joystick_float(x, y)
        self.gamepad.update()
        time.sleep(press_time)

    def release_left_joystick_float(self):
        self.gamepad.left_joystick_float(0, 0)
        self.gamepad.update()
        time.sleep(0.2)

    def press_and_release_left_joystick_float(self, x, y):
        self.press_left_joystick_float(x, y)
        self.release_left_joystick_float()

    def press_right_joystick(self, x, y):
        self.gamepad.right_joystick(x, y)
        self.gamepad.update()
        time.sleep(0.2)

    def release_right_joystick(self):
        self.gamepad.right_joystick(0, 0)
        self.gamepad.update()
        time.sleep(0.2)

    def press_and_release_right_joystick(self, x, y):
        self.press_right_joystick(x, y)
        self.release_right_joystick()

    def press_normal_button(self, button, press_time=0.2):
        self.gamepad.press_button(button=button)
        self.gamepad.update()
        time.sleep(press_time)

    def release_normal_button(self, button, sleep_after=0.2):
        self.gamepad.release_button(button=button)
        self.gamepad.update()
        time.sleep(sleep_after)

    def press_and_release_normal_buttons(self, button, press_time=0.2, sleep_after=0.2):
        self.press_normal_button(button, press_time=press_time)
        self.release_normal_button(button, sleep_after=sleep_after)

    def press_direction_button(self, button):
        self.gamepad.press_button(button)
        self.gamepad.update()
        time.sleep(0.2)

    def release_direction_button(self, button):
        self.gamepad.release_button(button)
        self.gamepad.update()
        time.sleep(0.1)

    def press_and_release_directions(self, button):
        self.press_direction_button(button)
        self.release_direction_button(button)

    def press_special_button(self, button, press_time=0.2):
        self.gamepad.press_button(button)
        self.gamepad.update()
        time.sleep(press_time)

    def release_special_button(self, button, sleep_after=0.2):
        self.gamepad.release_button(button)
        self.gamepad.update()
        time.sleep(sleep_after)

    def press_and_release_special_buttons(self, button, press_time=0.2, sleep_after=0.2):
        self.press_special_button(button, press_time=press_time)
        self.release_special_button(button, sleep_after=sleep_after)

    def press_l1(self):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)

    def release_l1(self):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER)

    def l1(self, press_time=0.2, sleep_after=0.2):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_SHOULDER,
                                              press_time=press_time, sleep_after=sleep_after)

    def press_r1(self, press_time=0.2):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER, press_time=press_time)

    def release_r1(self, sleep_after=0.2):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER, sleep_after=sleep_after)

    def r1(self):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_SHOULDER)

    def press_option(self):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_START)

    def release_option(self):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_START)

    def option(self):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_START)

    def press_cross(self, press_time=0.2):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_A, press_time=press_time)

    def release_cross(self, sleep_after=0.2):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_A, sleep_after=sleep_after)

    def cross(self, press_time=0.2, sleep_after=0.2):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_A,
                                              press_time=press_time, sleep_after=sleep_after)

    def press_circle(self):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_B)

    def release_circle(self):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_B)

    def circle(self, press_time=0.2):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_B, press_time=press_time)

    def press_triangle(self):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)

    def release_triangle(self):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)

    def triangle(self):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_Y)

    def press_square(self):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_X)

    def release_square(self):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_X)

    def square(self, press_time=0.2, sleep_after=0.2):
        self.press_and_release_normal_buttons(vg.XUSB_BUTTON.XUSB_GAMEPAD_X,
                                              press_time=press_time, sleep_after=sleep_after)

    def press_right(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)

    def release_right(self):
        self.release_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)

    def right(self, sleep_after=0):
        self.press_and_release_directions(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_RIGHT)
        if sleep_after:
            time.sleep(sleep_after)

    def press_left(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)

    def release_left(self):
        self.release_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)

    def left(self, sleep_after=0):
        self.press_and_release_directions(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_LEFT)
        if sleep_after:
            time.sleep(sleep_after)

    def press_up(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)

    def release_up(self):
        self.release_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)

    def up(self, sleep_after=0):
        self.press_and_release_directions(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_UP)
        if sleep_after:
            time.sleep(sleep_after)

    def press_down(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)

    def release_down(self):
        self.release_direction_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)

    def down(self, sleep_after=0):
        self.press_and_release_directions(vg.XUSB_BUTTON.XUSB_GAMEPAD_DPAD_DOWN)
        if sleep_after:
            time.sleep(sleep_after)

    def press_upright(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHEAST)

    def release_upright(self):
        self.release_direction_button()

    def upright(self):
        self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHEAST)

    def press_upleft(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHWEST)

    def release_upleft(self):
        self.release_direction_button()

    def upleft(self):
        self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHWEST)

    def press_downright(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHEAST)

    def release_downright(self):
        self.release_direction_button()

    def downright(self):
        self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHEAST)

    def press_downleft(self):
        self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHWEST)

    def release_downleft(self):
        self.release_direction_button()

    def downleft(self):
        self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHWEST)

    def press_ps(self, press_time=0.2):
        self.press_special_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_GUIDE, press_time=press_time)

    def release_ps(self, sleep_after=0.2):
        self.release_special_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_GUIDE, sleep_after=sleep_after)

    def ps(self, press_time=0.2, sleep_after=0.2):
        self.press_and_release_special_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_GUIDE,
                                               press_time=press_time, sleep_after=sleep_after)

    def press_r3(self):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)

    def release_r3(self):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)

    def r3(self):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_RIGHT_THUMB)

    def press_l3(self):
        self.press_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)

    def release_l3(self):
        self.release_normal_button(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)

    def l3(self):
        self.press_and_release_normal_buttons(button=vg.XUSB_BUTTON.XUSB_GAMEPAD_LEFT_THUMB)


class Uniqe_XBOXS_Buttons:
    def __init__(self):
        self.port = 5000
        self.host = '127.0.0.1'
        self.created = True
        try:
            with open('gamepad_port.txt', 'r') as gamepad_port:
                self.port = int(gamepad_port.read())
        except:
            self.created = False
            print('no gamepad port file')


    def __del__(self):
        if self.created:
            self.reset_to_default()

    def send_key(self, text: str, counter=0):
        if counter > 10:
            print('try more than 10 time. sleep 10 sec')
            time.sleep(10)
            return
        try:
            socket_object = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            socket_object.settimeout(20)
            socket_object.connect((self.host, self.port))
            socket_object.send(text.encode())
            reply = socket_object.recv(10)
            socket_object.close()
        except:
            print(counter, ' --- ', traceback.format_exc(), ' ip port : ', self.host, ':', self.port)
            return self.send_key(text, counter=counter + 1)

    def reset_to_default(self):
        self.send_key('reset_to_default()')

    def press_r2(self, sleep_after=.2):
        self.send_key(f'press_r2(sleep_after={sleep_after})')

    def release_r2(self, sleep_after=.2):
        self.send_key(f'release_r2(sleep_after={sleep_after})')

    def r2(self):
        self.send_key(f'r2()')

    def press_l2(self):
        self.send_key(f'press_l2()')

    def release_l2(self):
        self.send_key(f'release_l2()')

    def l2(self):
        self.send_key(f'l2()')

    def press_left_joystick(self, x, y, sleep_after=.2):
        self.send_key(f'press_left_joystick(x={x}, y={y}, sleep_after={sleep_after})')

    def release_left_joystick(self):
        self.send_key(f'release_left_joystick()')

    def press_and_release_left_joystick(self, x, y):
        self.send_key(f'press_and_release_left_joystick(x={x}, y={y})')

    def press_left_joystick_float(self, x, y, press_time=.2):
        self.send_key(f'press_left_joystick_float(x={x}, y={y}, press_time={press_time})')

    def release_left_joystick_float(self):
        self.send_key(f'release_left_joystick_float()')

    def press_and_release_left_joystick_float(self, x, y):
        self.send_key(f'press_and_release_left_joystick_float(x={x}, y={y})')

    def press_right_joystick(self, x, y):
        self.send_key(f'press_right_joystick(x={x}, y={y})')

    def release_right_joystick(self):
        self.send_key(f'release_right_joystick()')

    def press_and_release_right_joystick(self, x, y):
        self.send_key(f'press_and_release_right_joystick(x={x}, y={y})')

    def press_l1(self):
        self.send_key(f'press_l1()')

    def release_l1(self):
        self.send_key(f'release_l1()')

    def l1(self, press_time=0.2, sleep_after=0.2):
        self.send_key(f'l1(press_time={press_time}, sleep_after={sleep_after})')

    def press_r1(self, press_time=0.2):
        self.send_key(f'press_r1(press_time={press_time})')

    def release_r1(self, sleep_after=0.2):
        self.send_key(f'release_r1(sleep_after={sleep_after})')

    def r1(self):
        self.send_key(f'r1()')

    def press_option(self):
        self.send_key(f'press_option()')

    def release_option(self):
        self.send_key(f'release_option()')

    def option(self):
        self.send_key(f'option()')

    def press_cross(self, press_time=0.2):
        self.send_key(f'press_cross(press_time={press_time})')

    def release_cross(self, sleep_after=0.2):
        self.send_key(f'release_cross(sleep_after={sleep_after})')

    def cross(self, press_time=0.2, sleep_after=0.2):
        self.send_key(f'cross(press_time={press_time}, sleep_after={sleep_after})')

    def press_circle(self):
        self.send_key(f'press_circle()')

    def release_circle(self):
        self.send_key(f'release_circle()')

    def circle(self, press_time=0.2):
        self.send_key(f'circle(press_time={press_time})')

    def press_triangle(self):
        self.send_key(f'press_triangle()')

    def release_triangle(self):
        self.send_key(f'release_triangle()')

    def triangle(self):
        self.send_key(f'triangle()')

    def press_square(self):
        self.send_key(f'press_square()')

    def release_square(self):
        self.send_key(f'release_square()')

    def square(self, press_time=0.2, sleep_after=0.2):
        self.send_key(f'square(press_time={press_time}, sleep_after={sleep_after})')

    def press_right(self):
        self.send_key(f'press_right()')

    def release_right(self):
        self.send_key(f'release_right()')

    def right(self, sleep_after=0):
        self.send_key(f'right(sleep_after={sleep_after})')

    def press_left(self):
        self.send_key(f'press_left()')

    def release_left(self):
        self.send_key(f'release_left()')

    def left(self, sleep_after=0):
        self.send_key(f'left(sleep_after={sleep_after})')

    def press_up(self):
        self.send_key(f'press_up()')

    def release_up(self):
        self.send_key(f'release_up()')

    def up(self, sleep_after=0):
        self.send_key(f'up(sleep_after={sleep_after})')

    def press_down(self):
        self.send_key(f'press_down()')

    def release_down(self):
        self.send_key(f'release_down()')

    def down(self, sleep_after=0):
        self.send_key(f'down(sleep_after={sleep_after})')

    # def press_upright(self):
    #     self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHEAST)
    #
    # def release_upright(self):
    #     self.release_direction_button()
    #
    # def upright(self):
    #     self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHEAST)
    #
    # def press_upleft(self):
    #     self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHWEST)
    #
    # def release_upleft(self):
    #     self.release_direction_button()
    #
    # def upleft(self):
    #     self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_NORTHWEST)
    #
    # def press_downright(self):
    #     self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHEAST)
    #
    # def release_downright(self):
    #     self.release_direction_button()
    #
    # def downright(self):
    #     self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHEAST)
    #
    # def press_downleft(self):
    #     self.press_direction_button(button=vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHWEST)
    #
    # def release_downleft(self):
    #     self.release_direction_button()
    #
    # def downleft(self):
    #     self.press_and_release_directions(vg.XUSB_BUTTON.DS4_BUTTON_DPAD_SOUTHWEST)

    def press_ps(self, press_time=0.2):
        self.send_key(f'press_ps(press_time={press_time})')

    def release_ps(self, sleep_after=0.2):
        self.send_key(f'release_ps(sleep_after={sleep_after})')

    def ps(self, press_time=0.2, sleep_after=0.2):
        self.send_key(f'ps(press_time={press_time}, sleep_after={sleep_after})')

    def press_r3(self):
        self.send_key(f'press_r3()')

    def release_r3(self):
        self.send_key(f'release_r3()')

    def r3(self):
        self.send_key(f'r3()')

    def press_l3(self):
        self.send_key(f'press_l3()')

    def release_l3(self):
        self.send_key(f'release_l3()')

    def l3(self):
        self.send_key(f'l3()')
