import json
import sys
import time
import argparse
import threading
from PyQt5.QtCore import QThread
from PyQt5.QtWidgets import QApplication

from robot.client_socket import SocketRobotArm
from gui.init import MainContentComponent
from logger import logger


class MyApp:
    with open("./robots.json", "r") as file:
        robots = json.load(file)

    robot_app = None

    def __init__(self, mode):
        self.mode = mode

        self.startGui()
        self.startRobot()
        self.startWindow()

    def startGui(self):
        self.app = QApplication(sys.argv)
        mainWindow = MainContentComponent(
            get_status=self.get_status,
            robotPanel={
                "robots": self.robots,
                "updateRobot": self.updateRobot,
                "status": self.get_status,
            },
            statusPanel={
                "status": self.get_status,
            },
            informerPanel={
                "world_coord": self.get_world_coordinates,
                "axis_coord": self.get_axis_coordinates,
                "command_count": self.get_command_count,
                "updateData": self.update_data_wrapper,
            },
            imitatorPanel={
                "startImitate": self.imitate_wrapper,
                "imitate_point": self.get_imitate_point,
            },
            visPanel={
                "get_pybullet_image": self.get_pybullet_image_wrapper,
            },
        )
        mainWindow.setWindowTitle("ROBOT GUI")
        self.window = mainWindow

    def startWindow(self):
        self.window.show()
        sys.exit(self.app.exec_())

    def startRobot(self):
        self.robot_app = SocketRobotArm()
        # Запускаем SocketRobotArm в отдельном потоке
        threading.Thread(target=self.run_robot_arm, daemon=True).start()

    def run_robot_arm(self):
        time.sleep(1)
        self.robot_app.start("SHARED_MEMORY")

    def updateRobot(self, robot):
        if robot in self.robots:
            selected_robot = robot
            if self.mode == "test":
                selected_robot = {
                    "name": "test",
                    "host": "127.0.0.1",
                    "slave_id": 11,
                    "urdf": "sample",
                }

            if self.robot_app.status == "connected":
                self.robot_app.close()
                time.sleep(0.3)
            else:
                self.robot_app.connect(
                    selected_robot["host"], selected_robot["slave_id"]
                )
                self.robot_app.start_loop(selected_robot["urdf"])

    # Функции-обертки
    def get_status(self):
        if self.robot_app:
            return self.robot_app.get_status()
        else:
            return "not_connected"

    def get_world_coordinates(self):
        if self.robot_app:
            return self.robot_app.get_world_coordinates()
        return None  # Или любое значение по умолчанию

    def get_axis_coordinates(self):
        if self.robot_app:
            return self.robot_app.get_axis_coordinates()
        return None  # Или любое значение по умолчанию

    def get_command_count(self):
        if self.robot_app:
            return self.robot_app.get_command_count()
        return 0  # Или любое значение по умолчанию
    
    def get_imitate_point(self):
        if self.robot_app:
            return self.robot_app.get_imitate_point()
        return 0  # Или любое значение по умолчанию

    def imitate_wrapper(self):
        if self.robot_app:
            self.robot_app.imitate()
        else:
            print("robot_app еще не инициализирован.")
            
    def update_data_wrapper(self):
        if self.robot_app:
            self.robot_app.upd_model()
        else:
            print("robot_app еще не инициализирован.")

    def get_pybullet_image_wrapper(self):
        if self.robot_app:
            return self.robot_app.get_pybullet_image()
        return (None, 0, 0)  # Или любое значение по умолчанию


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="MyApp Command Line Interface")
    parser.add_argument(
        "--mode",
        type=str,
        choices=["test", "prod"],
        default="prod",
        help="Mode of operation",
    )
    # MyApp()
    args = parser.parse_args()
    app = MyApp(args.mode)