453 lines
20 KiB
Rust
453 lines
20 KiB
Rust
use crate::chat::ChatState;
|
|
use crate::config::AppConfig;
|
|
use crate::file_transfer::FileTransferManager;
|
|
use crate::media::MediaState;
|
|
use crate::net::{NetEvent, NetworkManager};
|
|
use crate::protocol::{self, GossipMessage};
|
|
use crate::tui::TuiCommand;
|
|
use anyhow::Result;
|
|
|
|
pub struct AppLogic {
|
|
pub chat: ChatState,
|
|
pub file_mgr: FileTransferManager,
|
|
pub media: MediaState,
|
|
pub net: NetworkManager,
|
|
pub our_name: String,
|
|
pub our_id_short: String,
|
|
pub connected: bool,
|
|
}
|
|
|
|
impl AppLogic {
|
|
pub fn new(
|
|
chat: ChatState,
|
|
file_mgr: FileTransferManager,
|
|
media: MediaState,
|
|
net: NetworkManager,
|
|
our_name: String,
|
|
our_id_short: String,
|
|
) -> Self {
|
|
Self {
|
|
chat,
|
|
file_mgr,
|
|
media,
|
|
net,
|
|
our_name,
|
|
our_id_short,
|
|
connected: false,
|
|
}
|
|
}
|
|
|
|
pub async fn handle_tui_command(&mut self, cmd: TuiCommand) -> Result<bool> {
|
|
match cmd {
|
|
TuiCommand::SendMessage(text) => {
|
|
if let Err(e) = self.chat.send_message(text, &self.net).await {
|
|
self.chat.add_system_message(format!("Send error: {}", e));
|
|
}
|
|
}
|
|
TuiCommand::SystemMessage(text) => {
|
|
self.chat.add_system_message(text);
|
|
}
|
|
TuiCommand::ToggleVoice => {
|
|
let status = self.media.toggle_voice(self.net.clone()).await;
|
|
self.chat.add_system_message(status.to_string());
|
|
}
|
|
TuiCommand::ToggleCamera => {
|
|
let status = self.media.toggle_camera(self.net.clone()).await;
|
|
self.chat.add_system_message(status.to_string());
|
|
}
|
|
TuiCommand::ToggleScreen => {
|
|
let status = self.media.toggle_screen(self.net.clone()).await;
|
|
self.chat.add_system_message(status.to_string());
|
|
}
|
|
TuiCommand::Quit => {
|
|
// Broadcast disconnect to peers
|
|
let disconnect_msg = GossipMessage::Disconnect {
|
|
sender_name: self.our_name.clone(),
|
|
};
|
|
let _ = self.net.broadcast(&disconnect_msg).await;
|
|
// Brief delay to let the message propagate
|
|
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
|
|
self.media.shutdown();
|
|
return Ok(true); // Signal to quit
|
|
}
|
|
TuiCommand::ChangeNick(new_nick) => {
|
|
let old = self.our_name.clone();
|
|
self.our_name = new_nick.clone();
|
|
self.chat.our_name = new_nick.clone();
|
|
// Update self in peer list
|
|
{
|
|
let mut peers = self.net.peers.lock().await;
|
|
if let Some(self_peer) = peers.get_mut(&self.net.our_id) {
|
|
self_peer.name = Some(new_nick.clone());
|
|
}
|
|
}
|
|
self.chat
|
|
.add_system_message(format!("Nickname changed: {} → {}", old, new_nick));
|
|
// Broadcast name change to all peers
|
|
let msg = GossipMessage::NameChange(protocol::NameChange {
|
|
old_name: old,
|
|
new_name: new_nick,
|
|
});
|
|
let _ = self.net.broadcast(&msg).await;
|
|
}
|
|
TuiCommand::Connect(peer_id_str) => {
|
|
match peer_id_str.parse::<crate::net::EndpointId>() {
|
|
Ok(peer_id) => {
|
|
self.chat
|
|
.add_system_message(format!("Connecting to {}...", peer_id));
|
|
if let Err(e) = self.net.connect(peer_id).await {
|
|
self.chat
|
|
.add_system_message(format!("Connection failed: {}", e));
|
|
} else {
|
|
self.chat
|
|
.add_system_message("Connection initiated.".to_string());
|
|
}
|
|
}
|
|
Err(_) => {
|
|
self.chat
|
|
.add_system_message(format!("Invalid peer ID: {}", peer_id_str));
|
|
}
|
|
}
|
|
}
|
|
TuiCommand::SendFile(path) => {
|
|
self.chat
|
|
.add_system_message(format!("Preparing to send file: {:?}", path));
|
|
if !path.exists() {
|
|
self.chat
|
|
.add_system_message(format!("File not found: {}", path.display()));
|
|
} else {
|
|
let file_mgr = self.file_mgr.clone();
|
|
// Prepare send
|
|
match file_mgr.prepare_send(&path).await {
|
|
Ok((file_id, offer)) => {
|
|
self.chat
|
|
.add_system_message(format!("Offering file: {}", offer.name));
|
|
let broadcast = protocol::FileOfferBroadcast {
|
|
sender_name: self.our_name.to_string(),
|
|
file_id,
|
|
file_name: offer.name.clone(),
|
|
file_size: offer.size,
|
|
timeout: offer.timeout,
|
|
};
|
|
let msg = GossipMessage::FileOfferBroadcast(broadcast);
|
|
if let Err(e) = self.net.broadcast(&msg).await {
|
|
self.chat.add_system_message(format!(
|
|
"Failed to broadcast offer: {}",
|
|
e
|
|
));
|
|
}
|
|
}
|
|
Err(e) => {
|
|
self.chat
|
|
.add_system_message(format!("Failed to prepare file: {}", e));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
TuiCommand::Leave => {
|
|
self.chat
|
|
.add_system_message("Leaving group chat...".to_string());
|
|
self.media.shutdown();
|
|
// Clear peer list (except self)
|
|
{
|
|
let mut peers = self.net.peers.lock().await;
|
|
peers.retain(|_, info| info.is_self);
|
|
}
|
|
self.chat.add_system_message(
|
|
"Session ended. Use /connect <peer_id> to start a new session.".to_string(),
|
|
);
|
|
}
|
|
TuiCommand::SelectMic(node_name) => {
|
|
self.media.set_mic_name(Some(node_name.clone()));
|
|
if self.media.voice_enabled() {
|
|
self.chat
|
|
.add_system_message("Restarting voice with new mic...".to_string());
|
|
// Toggle off
|
|
let _ = self.media.toggle_voice(self.net.clone()).await;
|
|
// Toggle on
|
|
let status = self.media.toggle_voice(self.net.clone()).await;
|
|
self.chat.add_system_message(status.to_string());
|
|
}
|
|
self.chat
|
|
.add_system_message(format!("🎤 Mic set to: {}", node_name));
|
|
// Save to config
|
|
if let Ok(mut cfg) = AppConfig::load() {
|
|
cfg.media.mic_name = Some(node_name);
|
|
let _ = cfg.save();
|
|
}
|
|
}
|
|
TuiCommand::SetBitrate(bps) => {
|
|
self.media.set_bitrate(bps);
|
|
self.chat
|
|
.add_system_message(format!("🎵 Bitrate set to {} kbps", bps / 1000));
|
|
// Save to config
|
|
if let Ok(mut cfg) = AppConfig::load() {
|
|
cfg.media.mic_bitrate = bps;
|
|
let _ = cfg.save();
|
|
}
|
|
}
|
|
TuiCommand::SelectSpeaker(node_name) => {
|
|
self.media.set_speaker_name(Some(node_name.clone()));
|
|
self.chat
|
|
.add_system_message(format!("🔊 Speaker set to: {}", node_name));
|
|
// Save to config
|
|
if let Ok(mut cfg) = AppConfig::load() {
|
|
cfg.media.speaker_name = Some(node_name);
|
|
if let Err(e) = cfg.save() {
|
|
tracing::warn!("Failed to save config: {}", e);
|
|
}
|
|
}
|
|
if self.media.voice_enabled() {
|
|
self.chat
|
|
.add_system_message("Restart voice chat to apply changes.".to_string());
|
|
}
|
|
}
|
|
TuiCommand::AcceptFile(prefix) => {
|
|
// Find matching transfer
|
|
let transfers = self.file_mgr.transfers.lock().unwrap();
|
|
let mut matched = None;
|
|
for (id, info) in transfers.iter() {
|
|
let id_str = hex::encode(id);
|
|
if id_str.starts_with(&prefix) {
|
|
if matched.is_some() {
|
|
self.chat
|
|
.add_system_message(format!("Ambiguous prefix '{}'", prefix));
|
|
matched = None;
|
|
break;
|
|
}
|
|
matched = Some((*id, info.clone()));
|
|
}
|
|
}
|
|
drop(transfers);
|
|
|
|
if let Some((_id, info)) = matched {
|
|
if let Some(peer_id) = info.peer {
|
|
self.chat
|
|
.add_system_message(format!("Requesting file from {}...", peer_id));
|
|
let req = protocol::FileRequest {
|
|
sender_name: self.our_name.clone(),
|
|
file_id: info.file_id,
|
|
};
|
|
|
|
// Update state to Requesting so we auto-accept when stream comes
|
|
let expires_at = std::time::Instant::now() + std::time::Duration::from_secs(60);
|
|
{
|
|
// We need to upgrade the lock or re-acquire?
|
|
// We dropped transfers lock at line 221.
|
|
let mut transfers = self.file_mgr.transfers.lock().unwrap();
|
|
if let Some(t) = transfers.get_mut(&info.file_id) {
|
|
t.state = crate::file_transfer::TransferState::Requesting { expires_at };
|
|
}
|
|
}
|
|
|
|
let msg = GossipMessage::FileRequest(req);
|
|
let _ = self.net.broadcast(&msg).await;
|
|
} else {
|
|
self.chat.add_system_message(
|
|
"Cannot accept: Sender unknown (legacy offer?)".to_string(),
|
|
);
|
|
}
|
|
} else {
|
|
self.chat
|
|
.add_system_message(format!("No transfer found matching '{}'", prefix));
|
|
}
|
|
}
|
|
TuiCommand::None => {}
|
|
}
|
|
Ok(false) // Do not quit
|
|
}
|
|
|
|
pub async fn handle_net_event(&mut self, event: NetEvent) {
|
|
match event {
|
|
NetEvent::GossipReceived { from, message } => match message {
|
|
GossipMessage::Chat(msg) => {
|
|
self.chat.receive_message(msg);
|
|
}
|
|
GossipMessage::Capabilities(caps) => {
|
|
let mut peers = self.net.peers.lock().await;
|
|
if let Some(peer) = peers.get_mut(&from) {
|
|
peer.name = Some(caps.sender_name.clone());
|
|
peer.capabilities = Some(caps);
|
|
}
|
|
}
|
|
GossipMessage::PeerAnnounce(announce) => {
|
|
let mut peers = self.net.peers.lock().await;
|
|
if let Some(peer) = peers.get_mut(&from) {
|
|
peer.name = Some(announce.sender_name.clone());
|
|
}
|
|
let short_id: String = format!("{}", from).chars().take(8).collect();
|
|
self.chat.add_system_message(format!(
|
|
"{} ({}) joined",
|
|
announce.sender_name, short_id
|
|
));
|
|
}
|
|
GossipMessage::FileOfferBroadcast(offer) => {
|
|
self.chat.add_system_message(format!(
|
|
"{} offers file: {} ({})",
|
|
offer.sender_name,
|
|
offer.file_name,
|
|
crate::file_transfer::format_bytes(offer.file_size)
|
|
));
|
|
self.file_mgr.register_incoming_broadcast(&offer, from);
|
|
}
|
|
GossipMessage::FileRequest(req) => {
|
|
let file_mgr = self.file_mgr.clone();
|
|
let net = self.net.clone();
|
|
let file_id = req.file_id;
|
|
let peer_id = from;
|
|
let sender_name = req.sender_name.clone();
|
|
|
|
// Check if we have transfer info
|
|
let transfer_opt = {
|
|
let transfers = file_mgr.transfers.lock().unwrap();
|
|
transfers.get(&file_id).cloned()
|
|
};
|
|
|
|
if let Some(info) = transfer_opt {
|
|
if let (Some(path), Some(offer)) = (info.path, info.offer) {
|
|
self.chat.add_system_message(format!(
|
|
"Starting transfer of {} to {}",
|
|
info.file_name, sender_name
|
|
));
|
|
|
|
tokio::spawn(async move {
|
|
// Open connection
|
|
match net.open_file_stream(peer_id).await {
|
|
Ok((mut send, mut recv)) => {
|
|
if let Err(e) = file_mgr
|
|
.execute_send(
|
|
file_id, &path, offer, &mut send, &mut recv,
|
|
)
|
|
.await
|
|
{
|
|
eprintln!("Transfer failed: {}", e);
|
|
let mut transfers = file_mgr.transfers.lock().unwrap();
|
|
if let Some(t) = transfers.get_mut(&file_id) {
|
|
t.state =
|
|
crate::file_transfer::TransferState::Failed {
|
|
error: e.to_string(),
|
|
completed_at: std::time::Instant::now(),
|
|
};
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
eprintln!(
|
|
"Failed to open connection to {}: {}",
|
|
peer_id, e
|
|
);
|
|
let mut transfers = file_mgr.transfers.lock().unwrap();
|
|
if let Some(t) = transfers.get_mut(&file_id) {
|
|
t.state = crate::file_transfer::TransferState::Failed {
|
|
error: format!("Conn error: {}", e),
|
|
completed_at: std::time::Instant::now(),
|
|
};
|
|
}
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
self.chat.add_system_message(
|
|
"Cannot send: Missing file path or offer details.".to_string(),
|
|
);
|
|
}
|
|
} else {
|
|
self.chat
|
|
.add_system_message("Received request for unknown file.".to_string());
|
|
}
|
|
}
|
|
GossipMessage::NameChange(change) => {
|
|
let mut peers = self.net.peers.lock().await;
|
|
if let Some(peer) = peers.get_mut(&from) {
|
|
peer.name = Some(change.new_name.clone());
|
|
}
|
|
self.chat.add_system_message(format!(
|
|
"✏️ {} is now known as {}",
|
|
change.old_name, change.new_name
|
|
));
|
|
}
|
|
GossipMessage::Disconnect { sender_name } => {
|
|
let mut should_exit = false;
|
|
{
|
|
let mut peers = self.net.peers.lock().await;
|
|
peers.remove(&from);
|
|
// Auto-terminate if no peers left
|
|
// We check if peers is empty. Note: we are not in peers map.
|
|
if peers.is_empty() {
|
|
should_exit = true;
|
|
}
|
|
}
|
|
let short_id: String = format!("{}", from).chars().take(8).collect();
|
|
self.chat.add_system_message(format!(
|
|
"👋 {} ({}) disconnected",
|
|
sender_name, short_id
|
|
));
|
|
|
|
if should_exit && self.connected {
|
|
self.chat
|
|
.add_system_message("All peers disconnected. Exiting...".to_string());
|
|
// Trigger shutdown
|
|
self.media.shutdown();
|
|
std::process::exit(0);
|
|
}
|
|
}
|
|
},
|
|
NetEvent::PeerUp(peer_id) => {
|
|
let short_id: String = format!("{}", peer_id).chars().take(8).collect();
|
|
self.chat
|
|
.add_system_message(format!("Peer connected: {}", short_id));
|
|
self.connected = true;
|
|
}
|
|
NetEvent::PeerDown(peer_id) => {
|
|
let mut should_exit = false;
|
|
{
|
|
let mut peers = self.net.peers.lock().await;
|
|
peers.remove(&peer_id);
|
|
if peers.is_empty() {
|
|
should_exit = true;
|
|
}
|
|
}
|
|
let short_id: String = format!("{}", peer_id).chars().take(8).collect();
|
|
self.chat
|
|
.add_system_message(format!("Peer disconnected: {}", short_id));
|
|
|
|
if should_exit && self.connected {
|
|
self.chat
|
|
.add_system_message("All peers disconnected. Exiting...".to_string());
|
|
self.media.shutdown();
|
|
std::process::exit(0);
|
|
}
|
|
}
|
|
NetEvent::IncomingFileStream {
|
|
from,
|
|
mut send,
|
|
mut recv,
|
|
} => {
|
|
self.chat
|
|
.add_system_message("Incoming file transfer...".to_string());
|
|
tracing::info!("Incoming file stream from {:?}", from);
|
|
let file_mgr = self.file_mgr.clone();
|
|
tokio::spawn(async move {
|
|
if let Err(e) = file_mgr.execute_receive(&mut send, &mut recv).await {
|
|
tracing::error!("File receive failed: {}", e);
|
|
}
|
|
});
|
|
}
|
|
NetEvent::IncomingMediaStream {
|
|
from,
|
|
kind,
|
|
send,
|
|
recv,
|
|
} => {
|
|
let short_id: String = format!("{}", from).chars().take(8).collect();
|
|
self.chat
|
|
.add_system_message(format!("📡 Incoming {:?} stream from {}", kind, short_id));
|
|
self.media.handle_incoming_media(from, kind, send, recv);
|
|
}
|
|
NetEvent::IncomingDatagram { from, data } => {
|
|
self.media.handle_incoming_datagram(from, data);
|
|
}
|
|
}
|
|
}
|
|
}
|