import time
from enum import Enum

from action_msgs.msg import GoalStatus
from geometry_msgs.msg import PoseStamped
from nav2_msgs.action import NavigateThroughPoses
from nav2_msgs.srv import ManageLifecycleNodes

import rclpy
from rclpy.action import ActionClient
from rclpy.node import Node


class TaskResult(Enum):
    """Enum for task result."""
    UNKNOWN = 0
    SUCCEEDED = 1
    CANCELED = 2
    FAILED = 3


class Navigator(Node):
    """
    Um navegador simplificado para enviar uma lista de poses para o Nav2.
    Focado para setups sem mapa e sem AMCL.
    """

    def __init__(self, node_name='navigator', namespace=''):
        super().__init__(node_name=node_name, namespace=namespace)
        self.goal_handle = None
        self.result_future = None
        self.feedback = None
        self.status = None

        # Clientes essenciais
        self.nav_through_poses_client = ActionClient(
            self, NavigateThroughPoses, 'navigate_through_poses')
        self.lifecycle_manager_client = self.create_client(
            ManageLifecycleNodes, 'lifecycle_manager_navigation/manage_nodes')

    def destroy_node(self):
        self.info('Destruindo o Navigator.')
        self.nav_through_poses_client.destroy()
        self.lifecycle_manager_client.destroy()
        super().destroy_node()

    def startup(self):
        """
        Ativa os nós de ciclo de vida do Nav2 enviando um único comando
        para o gerenciador de ciclo de vida.
        """
        self.info('Enviando comando STARTUP para o lifecycle_manager_navigation...')
        
        while not self.lifecycle_manager_client.wait_for_service(timeout_sec=1.0):
            self.info('Serviço do lifecycle_manager_navigation não disponível, aguardando...')

        req = ManageLifecycleNodes.Request()
        req.command = ManageLifecycleNodes.Request.STARTUP
        
        future = self.lifecycle_manager_client.call_async(req)
        rclpy.spin_until_future_complete(self, future)

        if future.result() and future.result().success:
            self.info('Nós do Nav2 ativados com sucesso.')
        else:
            self.error('Falha ao ativar os nós do Nav2.')
        return

    def goThroughPoses(self, poses, behavior_tree=''):
        """
        Envia uma lista de poses para o Nav2 seguir.
        """
        self.info("Aguardando o servidor de ação 'navigate_through_poses'...")
        while not self.nav_through_poses_client.wait_for_server(timeout_sec=1.0):
            self.info("'navigate_through_poses' não disponível, aguardando...")

        goal_msg = NavigateThroughPoses.Goal()
        goal_msg.poses = poses
        goal_msg.behavior_tree = behavior_tree

        self.info(f'Enviando {len(goal_msg.poses)} waypoints para o Nav2...')
        send_goal_future = self.nav_through_poses_client.send_goal_async(
            goal_msg, self._feedbackCallback)
        
        rclpy.spin_until_future_complete(self, send_goal_future)
        self.goal_handle = send_goal_future.result()

        if not self.goal_handle.accepted:
            self.error('O objetivo de seguir os waypoints foi rejeitado!')
            return False

        self.result_future = self.goal_handle.get_result_async()
        self.info('Objetivo aceito, iniciando a navegação...')
        return True

    def cancelTask(self):
        """Cancela a tarefa atual."""
        self.info('Cancelando a tarefa atual.')
        if self.result_future:
            future = self.goal_handle.cancel_goal_async()
            rclpy.spin_until_future_complete(self, future)
        return

    def isTaskComplete(self):
        """Verifica se a tarefa foi concluída."""
        if not self.result_future:
            return True
        
        rclpy.spin_until_future_complete(self, self.result_future, timeout_sec=0.10)
        
        if self.result_future.result():
            self.status = self.result_future.result().status
            if self.status != GoalStatus.STATUS_SUCCEEDED:
                return True
        else:
            return False

        return True

    def getFeedback(self):
        """Retorna o feedback da ação atual."""
        return self.feedback

    def getResult(self):
        """Retorna o resultado final da tarefa."""
        if self.status == GoalStatus.STATUS_SUCCEEDED:
            return TaskResult.SUCCEEDED
        elif self.status == GoalStatus.STATUS_ABORTED:
            return TaskResult.FAILED
        elif self.status == GoalStatus.STATUS_CANCELED:
            return TaskResult.CANCELED
        else:
            return TaskResult.UNKNOWN

    def _feedbackCallback(self, msg):
        self.feedback = msg.feedback
        return

    # Funções de logging
    def info(self, msg):
        self.get_logger().info(msg)

    def warn(self, msg):
        self.get_logger().warn(msg)

    def error(self, msg):
        self.get_logger().error(msg)

    def debug(self, msg):
        self.get_logger().debug(msg)