pub struct Server {
    /// ID del server
    pub id: u64,
    /// ID del server lider
    pub id_leader: u64,
    /// Booleano indicando si es líder
    pub im_leader: bool,
    /// Drivers disponibles segun su nombre
    /// El server envía esta información a los pasajeros
    pub drivers: HashMap<String, DriverInfo>,
    /// Drivers ocupados segun su nombre
    pub busy_drivers: HashMap<String, DriverInfo>,
    /// ID de pasajeros segun su nombre
    pub passengers: HashMap<String, u64>,
    /// Conexiones con pasajeros segun sus IDs
    pub passengers_address: HashMap<u64, Addr<TcpSender>>,
    /// Sockets de servidores replicas
    pub udp_sockets_replicas: HashMap<u64, String>,
    /// Conexiones con servers segun su ID
    pub servers: HashMap<u64, Addr<TcpSender>>,
    /// Contador de IDs
    pub ids_count: u64,
    /// Sender UDP
    pub udp_sender: Option<Addr<UdpSender>>,
    /// Conexion con el lider. Es None en caso de ser el lider.
    pub leader_connection: Option<Addr<ServerConnection>>,
    /// Listado de servers desconectados
    pub disconnected_servers: Vec<u64>,
    /// Booleano indicando si se recibio el ACK del vecino
    pub received_neighbor_ack: bool,
    /// Booleano indicando si hay una eleccion de lider en curso
    pub election_on_course: bool,
    /// ID del vecino actual
    pub actual_neighbor_id: u64,
    /// Numero de secuencia actual
    pub sequence_number: u64,
    /// Booleano que indica si se recibio ACK para un numero de secuencia
    pub message_received_ack: HashMap<u64, bool>,
}

/// Luego de que el Driver se haya conectado, se recibe este mensaje para identificarlo como driver
/// En el se recibe el nombre del driver (identificador). En caso de que el driver no este registrado
/// lo registra y lo guarda en la lista de drivers disponibes
struct NewDriver {
    /// IP y puerto del conductor
    socket: String,
    /// Nombre del conductor (para identificarlo)
    name: String,
    /// Ubicación actual del conductor
    position: (u64 u64),
}

/// El conductor envia este mensaje para informarle al Server que está ocupado (en viaje con un pasajero).
/// Al recibir este mensaje, el Server marca al conductor como ocupado (lo elimina del hashmap con los 
/// conductores disponibles, y lo agrega al hashmap de conductores ocupados).
/// De esta forma, el Server va a enviarle a los pasajeros sólo aquellos conductores que estén disponibles.
struct BusyDriver {
    name: String,
}

/// El conductor envía este mensaje al Server cuando está disponible.
/// Al recibir este mensaje, el Server marca al conductor como disponible, y actualiza
/// su ubicación en el hashmap de conductores disponibles.
struct AvailableDriver {
    name: String,
    /// La ubicación actualizada del conductor.
    new_position: (u64, u64),
}

pub struct UpdateDriver {
    pub new_position: (u64, u64),
    pub name: String,
}

pub struct ReconnectDriver {
    pub id_passenger: u64,
    pub socket: String,
    pub name: String,
}

pub struct UpdateDriverSocket {
    pub socket: String,
    pub name: String,
}

/// Representa el "registro" de un pasajero en la red.
/// El Server se guarda el `name` del pasajero, le asocia un id y le manda un mensaje informándole su id.
struct PassengerLogin {
   name: String, 
}

/// El pasajero le pide la información de los conductores al Server.
/// El Server le responde con el mensaje `Drivers`, que contiene 
/// información del conductor (IP, puerto, ubicación, etc).
struct GetDrivers {}

pub struct NewServerConnection {
    /// Address del actor TcpSender
    pub addr: Addr<TcpSender>,
    /// Socket de la conexión (IP y puerto).
    pub socket: String,
    /// Id de la conexión.
    pub id: u64,
}

pub struct Ping {}

pub struct Pong {
    pub addr: Addr<TcpSender>,
}

pub struct UpdateNetworkState {
    /// Contador de ids
    pub ids_count: u64,
    /// Un hashmap con los conductores disponibles.
    pub drivers: HashMap<String, DriverInfo>,
    /// Un hashmap con los conductores ocupados.
    pub busy_drivers: HashMap<String, DriverInfo>,
    /// Un hashmap que mapea el nombre del pasajero a un id
    pub passengers: HashMap<String, u64>,
    /// Sockets UDP de servidores replica segun el id
    pub udp_sockets_replicas: HashMap<u64, String>,
    /// Vector con los ids de los servidores que estan desconectados
    pub disconnected_servers: Vec<u64>,
}

pub struct SetLeader {
    pub leader_connection: Addr<ServerConnection>,
}

pub struct StartElection {}

pub struct WaitForNeighborAck {
    /// Mensaje que envíe a la réplica
    pub serialized_msg: String,
    /// ID de la réplica
    pub neighbor_id: u64,
    /// Numero de secuencia del mensaje
    pub sequence_number: u64,
}

pub struct CheckIfNeighborAcked {
    /// ID de la réplica a quien le envíe un mensaje
    pub neighbor_id: u64,
    /// Mensaje que envié
    pub serialized_msg: String,
    /// Numero de secuencia.
    pub sequence_number: u64,
}

pub struct Election {
    /// ID del líder que se cayó.
    pub disconnected_leader_id: u64,
    /// Listado de IDs de servidores réplicas conectados
    pub server_ids: Vec<u64>,
    /// Número de secuencia del mensaje.
    pub sequence_number: u64,
}

pub struct NewLeader {
    /// ID del server que determinó el nuevo líder.
    pub id_sender: u64,
    /// ID del nuevo líder.
    pub leader_id: u64,
    /// Número de secuencia.
    pub sequence_number: u64,
}

pub struct NeighborAck {
    /// ID de la réplica
    pub id: u64,
    /// Mensaje al cual corresponde el ACK
    pub message: String,
    /// Numero de secuencia
    pub sequence_number: u64,
}

pub struct ConnectToServer {}

pub struct TcpMessage(pub String);

pub struct UpdateNetworkState {
    /// Contador de ids
    pub ids_count: u64,
    /// Un hashmap con los conductores disponibles.
    pub drivers: HashMap<String, DriverInfo>,
    /// Un hashmap con los conductores ocupados.
    pub busy_drivers: HashMap<String, DriverInfo>,
    /// Un hashmap que mapea el nombre del pasajero a un id
    pub passengers: HashMap<String, u64>,
    /// Sockets UDP de servidores replica segun el id
    pub udp_sockets_replicas: HashMap<u64, String>,
    /// Vector con los ids de los servidores que estan desconectados
    pub disconnected_servers: Vec<u64>,
}

struct TcpSender {
    /// El extremo de escritura del socket
    write: WriteHalf<TcpStream>,
    /// El address del actor `Server`, para forwardearle los mensajes
    server_addr: Addr<Server>,
}

struct TcpMessage {
    /// Un string JSON que contiene los campos del mensaje original
    msg: String
}

pub struct ServerConnection {
    /// Address del server
    pub addr: Addr<Server>,
    /// Extremo de escritura del socket
    pub write: Option<WriteHalf<TcpStream>>,
    /// Tiempo de respuesta luego del cual se considera caido el server lider
    pub response_time: Instant,
}

struct TcpMessage {
    /// Un string JSON que contiene los campos del mensaje original
    msg: String
}

pub struct UdpReceiver {
    /// Socket UDP
    pub socket: Arc<UdpSocket>,
    /// Address del actor socket
    pub server: Option<Addr<Server>>,
}

/// Escucha mensajes UDP, los deserializa y envia el respectivo mensaje de actix al server.
pub struct Listen {}

pub struct UdpSender {
    pub socket: Arc<UdpSocket>,
}

/// Representa un mensaje UDP, con el contenido y el destino.
pub struct UdpMessage {
    pub message: String,
    pub dst: String,
}

pub struct ConnectionListener {
    /// Socket en el cual escucha conexiones
    pub socket: String,
    /// Address del actor Server
    pub server_addr: Addr<Server>,
}

  /// Escucha por conexiones TCP.
  pub struct Listen {}

pub struct Passenger {
    /// Nombre del pasajero
    pub name: String,
    /// Informacion del pasajero
    pub info: PassengerInfo,
    /// Booleano de recuperacion en caso de caida
    pub recovery: bool,
    /// Booleano del estado de la autorizacion
    pub payment_authorized: bool,
    /// Booleano del estado del pago
    pub payment_confirmed: bool,
    /// Comunicacion con el servidor
    pub server_receiver: Option<Addr<TcpReceiver>>,
    /// Comunicacion con el servidor
    pub server_sender: Addr<TcpSender>,
    /// Conexiones
    pub connections: Vec<Addr<TcpSender>>,
    // Informacion de los conductores que recibe del servidor
    pub drivers_info: Vec<DriverInfo>,
    /// Socket del conductor seleccionado
    pub driver_socket: Option<String>,
    // Comunicacion con el Gateway
    pub gateway: Addr<GatewayConnection>,
}

struct PassengerInfo {
    /// ID del pasajero asignado por el servidor
    pub id: usize,
    /// Posicion origen
    pub position: (u64, u64),
    /// Posicion destino
    pub destination: (u64, u64),
}

struct DriverInfo {
    /// Socket del conductor
    pub socket: String,
    /// Posicion origen
    pub position: (u64, u64),
}

// Se utiliza para almacenar la direccion del actor TcpReceiver que se utiliza para comunicarse con el servidor
  pub struct SetReceiver {
      /// Comunicacion con el servidor. Direccion del actor TcpReceiver.
      pub receiver: Addr<TcpReceiver>,
  }

/// Solicita al servidor los conductores disponibles para poder comunicarse con ellos y concretar el viaje. Luego de enviar el mensaje valida que la conexion con el servidor exista, en caso de que se haya perdido la conexion se reconecta con el nuevo lider y reenvia el mensaje para no perder informacion.
  struct GetDrivers {}

/// Selecciona un conductor segun la cercania y se comunica con el Gateway para solicitar autorizacion para realizar el viaje. Almacena la conexion con el conductor seleccionado. En caso de existir algun tipo de error, vuelve a intentar seleccionar otro conductor.
  struct Drivers {
      // Informacion de los conductores
      pub drivers_info: Vec<DriverInfo>,
  }

/// Se loguea en el servidor, registrandose con su nombre. Si la conexion esta caida, se conecta con el nuevo lider.
  struct Login {
      /// Nombre del pasajero
      pub name: String,
  }

/// Se encarga de actualizar la posicion del pasajero simulando el viaje. Una vez que llega a destino finaliza el viaje y le solicita la confirmacion del pago al Gateway.
  pub struct Traveling {}

/// Indica que el conductor se encuentra en el lugar de partida, listo para comenzar el viaje. Inicia el viaje.
pub struct DriverArrived {}

/// Recibe del servidor el ID con el cual se identifica en el servidor y lo guarda
    struct CompleteLogin {
        /// ID del pasajero asignado por el servidor
        pub id: usize,
    }

/// Indica que el conductor acepto el viaje. Luego espera a que el conductor le notifique que llego al punto de partida.
pub struct RideAccepted {}

/// Solicita al conductor un viaje a un destino en particular
    struct RequestDrive {}

/// En caso de que el conductor rechace el viaje, vuelve a iniciar otra busqueda
    struct KeepLooking {}

/// Indica que el pago fue autorizado por el Gateway actualizando el estado
pub struct PaymentAuthorized {}

// El pago fue denegado por el Gateway, comienzo nuevamente la busqueda por un conductor
pub struct PaymentDeny {}

/// Luego de identificar la perdida de conexion y que el conductor se encontraba en viaje, recibe el estado del mismo de parte del conductor
pub struct RecoverResponse {
    /// Booleano que indica si el conductor levanto al pasajero
    pub picked_up: bool,
    /// Posicion actual del conductor
    pub position: (u64, u64),
    /// Booleano que indica si el viaje finalizo
    pub end_ride: bool,
}

/// En caso de que se pierda la conexion con el servidor lider, intenta reconectarse al nuevo lider. Se reconecta y almacena todos los caneles de comunicacion con el servidor lider, luego le reenvia el mensaje que no pudo enviarse debido a la caida del mismo
pub struct Reconnect {
    /// Mensaje serializado que debe reenviarse
    pub serialized_msg: String,
}

/// Recibe del servidor la notificacion de que el conductor se reconecto y se intenta reconectar al conductor. Si es posible se almacena la conexion y envia al conductor un mensaje que indica el intento de reconexion. En caso contrario notifica que hay un error.
pub struct ReconnectDriver {
    /// Socket del conductor caido
    pub socket: String,
}

/// Dado que perdimos la conexion, restauramos nuestro estado utilizando el archivo correspondiente.
/// Si el pago habia sido confirmado, entonces indica que el viaje termino.
/// Si el pago no fue autorizado, entonces indica que no estoy en viaje ni solicitando uno.
/// Caso contrario, si tengo un conductor asignado, entonces estoy en viaje y le solicito el estado del mismo.
pub struct Recover {
    /// Estado leìdo del archivo corrrespondiente
    pub status: Value,
}

pub struct TcpMessage(pub String);

  pub struct TcpSender {
    /// Escritura asíncrona en la conexión TCP
    pub write: Option<WriteHalf<TcpStream>>,
    /// Dirección de socket asociada
    pub addr: SocketAddr,
}

/// Envia al servidor el contenido del mensaje recibido
struct TcpMessage(pub String);

  pub struct TcpReceiver {
    /// Dirección de socket asociada
    pub addr: SocketAddr,
    /// Direccion del actor del pasajero
    pub client_addr: Addr<Passenger>,
}

    struct Drivers {
        pub drivers_info: Vec<DriverInfo>,
    }

    struct CompleteLogin {
        pub id: usize,
    }

    struct RideAccepted {
      pub driver_socket: String,
    }

    struct DriverArrived {}

    struct KeepLooking {}

    struct RecoverResponse {
      /// Booleano que indica si el conductor levanto al pasajero
      pub picked_up: bool,
      /// Posicion actual del conductor
      pub position: (u64, u64),
      /// Booleano que indica si el viaje finalizo
      pub end_ride: bool,
    }

    struct ReconnectDriver {
      /// Socket del conductor caido
      pub socket: String,
    }

  pub struct GatewayConnection {
      // Direccion del actor del pasajero
      pub passenger: Option<Addr<Passenger>>,
      /// Escritura asíncrona en la conexión TCP
      pub write: Option<WriteHalf<TcpStream>>,
  }

  struct PaymentAuthorized {}

    struct RequestDrive {}

/// Recibe este mensaje cuando el pago fue autorizado por el Gateway
    struct AuthorizePayment {}

/// Almacena al actor pasajero dentro del actor que representa la conexion con el Gateway
pub struct SetPassenger {
    // Direccion del actor del pasajero
    pub passenger: Addr<Passenger>,
}

/// Envia al actor Gateway el contenido del mensaje recibido
    pub struct TcpMessage(pub String);

pub struct Driver {
    pub server_receiver: Option<Addr<TcpReceiver>>,// direccion para recibir mensajes del servidor lider
    pub server_sender: Addr<TcpSender>,// Dirección para enviar mensajes al servidor líder.
    pub connections: Vec<Addr<PassengerConnection>>,// Lista de conexiones con los pasajeros.
    pub id_current_passenger: usize, // ID del pasajero actual.
    pub is_available: bool, // Indica si el conductor está disponible.
    pub is_registered: bool, // Indica si el conductor esta registrado en el servidor
    pub position: (u64, u64), // Posición actual del conductor
    pub passenger_position: Option<(u64, u64)>, // Posición del pasajero
    pub destination: Option<(u64, u64)>, // Destino actual (si existe).
    pub name: String,  // Nombre del conductor.
    pub current_passenger_connection: Option<Addr<PassengerConnection>>, // Almacena el canal de comunicacion con el pasajero
    pub passenger_picked_up: bool, // indica si el conductor recogio al pasajero
    pub driver_socket: String, // Almacena la direccion IP del socket de conductor
}

struct TcpMessage {
    content: String, // Mensaje serializado que se envía al servidor.
}

struct PassengerConnectionMessage(pub String);

pub struct Reconnect {
    pub serialized_msg: String,
}

pub struct PickUpPassenger {}

pub struct RideToDestination {}

pub struct StartRide {}

struct Register {
    socket: String,
    name: String,
    position: (u64, u64),
}

struct NewConnection {
    addr: Addr<PassengerConnection>,
}

struct RequestRide {
    id_passenger: usize,
    origin: (u64, u64),
    destination: (u64, u64),
    addr: Addr<PassengerConnection>,
}

struct EndRide {
  dst: (u64, u64),
}

pub struct PassengerRecover {
    pub id_passenger: u64,
    pub passenger_connection: Addr<PassengerConnection>,
}

pub struct Recovery {
    pub status: Value,
    pub socket: String,
}

pub struct SetReceiver {
    pub receiver: Addr<TcpReceiver>,
}

pub struct ReconnectPassenger {
    pub passenger_connection: Addr<PassengerConnection>,
    pub position: (u64, u64),
}

struct PassengerConnection {
    write: Option<WriteHalf<TcpStream>>, // Manejador para escritura asíncrona en la conexión TCP.
    addr: SocketAddr,                    // Dirección de socket del pasajero.
    driver_addr: Addr<Driver>,           // Dirección del actor `Driver` asociado.
}

struct RequestRide {
    id_passenger: usize,
    origin: (u64, u64),
    destination: (u64, u64),
    addr: Addr<PassengerConnection>,
}

pub struct PassengerRecover {
    pub id_passenger: u64,
    pub passenger_connection: Addr<PassengerConnection>,
}

pub struct ReconnectPassenger {
    pub passenger_connection: Addr<PassengerConnection>,
    pub position: (u64, u64),
}

struct PassengerConnectionMessage(pub String);

struct TcpSender {
    write: Option<WriteHalf<TcpStream>>, // Manejador para escritura asíncrona en la conexión TCP.
    addr: SocketAddr,                    // Dirección de socket asociada.
}

struct TcpMessage(pub String);

struct TcpSender {
    /// Extremo de escritura del socket
    write: Option<WriteHalf<TcpStream>>,
    /// Address del gateway, para forwardearle los mensajes del socket
    gateway_addr: Addr<Gateway>,
}

struct TcpMessage {
    /// Un string JSON que contiene los campos del mensaje original
    msg: String
}

struct Gateway {
    /// Un hashmap nombre_pasajero => id_pasajero.
    passengers: HashMap<String, u64>
    /// Conexiones con los pasajeros de la red.
    connections: Vec<Addr<TcpSender>>,
}

/// Al recibir este mensaje, el Gateway se guarda el nombre del usuario
/// y le asigna un id, enviandole un mensaje Id.
struct Login {
    /// Nombre que identifica al pasajero 
    name: String,
}

/// Al recibir este mensaje, el Gateway le responde al pasajero un mensaje `PaymentAuthorizationStatus`
/// el cual contiene un booleano que indica si el pago fue autorizado o no (segun una probabilidad).
struct AuthorizePayment {
    /// Nombre que identifica al pasajero 
    name: String,
}

/// Al recibir este mensaje, el Gateway le responde al pasajero un mensaje `PaymentConfirmationStatus`
/// el cual contiene un booleano que indica si el pago fue confirmado o no.
struct ConfirmPayment {
    /// Nombre que identifica al pasajero 
    name: String,
}

/// Mediante este mensaje el Gateway le asigna un id al pasajero.
struct Id {
    /// Nuevo id del pasajero
    id: u64,
}

/// Este mensaje sirve para indicarle al pasajero si el pago solicitado previamente fue autorizado o no.
struct PaymentAuthorizationStatus {
    is_authorized: bool,
}

/// Este mensaje sirve para indicarle al pasajero si el pago solicitado previamente fue confirmado o no
struct PaymentConfirmationStatus {
    is_confirmed: bool,
}