why2-chat 2.1.4

/*
This is part of WHY2
Copyright (C) 2022-2026 Václav Šmejkal

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <https://www.gnu.org/licenses/>.
*/

use std::
{
    io::Error,
    time::Instant,
};

use crossterm::event::
{
    KeyCode,
    KeyEvent,
    KeyModifiers,
};

use zeroize::Zeroizing;

use tokio::
{
    sync::mpsc::Sender,
    net::tcp::{ OwnedReadHalf, OwnedWriteHalf },
};

use crate::
{
    config,
    options,
    network::client,
};

use super::
{
    consts,
    input::InputBuffer,
    state::App,
};

//TYPES
//ONE FINISHED DIAL ATTEMPT, NUMBERED
pub type ConnectResult = (u64, Result<(OwnedReadHalf, OwnedWriteHalf), Error>);

//ENUMS
pub enum Action //WHAT THE LOOP HAS TO DO AFTER A KEYSTROKE
{
    None,
    Connect,
    Submit, //AN ANSWERED IDENTITY STEP
    Quit,
}

#[derive(Clone, Copy, PartialEq)] //WHICH OF THE THREE THINGS THE BOX IS ASKING FOR
pub enum Stage
{
    Address,
    Username,
    Password { register: bool },
}

//STRUCTS
pub struct Login //THE CONNECT PROMPT
{
    pub input: InputBuffer,
    pub stage: Stage,
    pub busy: bool,            //A DIAL, OR AN ANSWER THE SERVER HAS NOT REPLIED TO YET
    pub connected: bool,       //THE SOCKET IS OPEN
    pub error: Option<String>, //WHY THE LAST ONE DID NOT WORK
    pub hint: Option<String>,  //THE SERVER'S RULES FOR THE STEP ON SCREEN
    attempt: u64,              //ONLY THE NEWEST ATTEMPT'S RESULT IS ACCEPTED
}

//WHAT AN AUTOMATIC RE-DIAL NEEDS AFTER A DROPPED SESSION
#[derive(Default)]
pub struct Reconnect
{
    credentials: Option<(String, Zeroizing<String>)>, //WHAT GOT US IN, ONCE IT ACTUALLY DID
    typed: (String, Zeroizing<String>),               //THE ANSWERS OF THE STEPS IN FLIGHT
    due: Option<Instant>,                             //WHEN TO DIAL AGAIN
    left: u32,                                        //ATTEMPTS BEFORE IT GIVES UP AND WAITS FOR A KEY
    answers: u32,                                     //REPLIES THIS DIAL MAY STILL REPLAY - USERNAME AND PASSWORD
    retrying: bool,                                   //THE BOX IS BUSY BECAUSE OF US, NOT BECAUSE OF A KEYPRESS
    pub submit: bool,                                 //AN ANSWER IS IN THE FIELD FOR THE TICK TO SEND
}

//IMPLEMENTATIONS
impl Reconnect
{
    //KEEP WHAT WAS TYPED AT EACH STEP
    pub fn remember(&mut self, stage: Stage, text: &str)
    {
        match stage
        {
            Stage::Username => self.typed.0 = text.to_owned(),
            Stage::Password { .. } => self.typed.1 = Zeroizing::new(text.to_owned()),
            Stage::Address => {},
        }
    }

    //THE PAIR WORKED, SO IT IS WORTH REPLAYING
    pub fn accepted(&mut self)
    {
        self.credentials = Some(self.typed.clone());
        self.left = consts::RECONNECT_ATTEMPTS;
        self.retrying = false;
        self.due = None;
    }

    //THE USER ASKED TO LEAVE, OR CANCELLED THE DIAL
    pub fn forget(&mut self) { *self = Self::default(); }

    //SCHEDULE A DIAL, IF THERE IS ANYTHING TO LOG BACK IN WITH
    pub fn arm(&mut self) -> bool
    {
        if self.credentials.is_none() || self.left == 0
        {
            self.retrying = false; //OUT OF TRIES - THE NEXT DIAL IS THE USER'S OWN

            return false;
        }

        self.left -= 1;
        self.retrying = true;
        self.answers = 2; //A SERVER THAT KEEPS ASKING IS NOT ANSWERED FOREVER
        self.due = Some(Instant::now() + consts::RECONNECT_DELAY);

        true
    }

    //WHAT THE BOX SAYS WHILE IT IS DIALLING ITSELF BACK
    pub fn status(&self) -> Option<String>
    {
        self.retrying.then(|| format!("Connection lost, reconnecting… ({}/{})",
            consts::RECONNECT_ATTEMPTS - self.left, consts::RECONNECT_ATTEMPTS))
    }

    //WHETHER THE WAIT IS UP
    pub fn take_due(&mut self) -> bool
    {
        if self.due.is_none_or(|due| Instant::now() < due) { return false; }

        self.due = None;

        true
    }

    //THE ANSWER THE SERVER'S NEXT STEP WANTS
    pub fn answer(&mut self, stage: Stage) -> Option<String>
    {
        //ONLY A DIAL WE STARTED REPLAYS ANYTHING - A DIAL THE USER TYPED IS THEIRS TO ANSWER
        if !self.retrying || self.answers == 0 { return None; }

        let (username, password) = self.credentials.as_ref()?;

        let answer = match stage
        {
            Stage::Username => username.clone(),
            Stage::Password { register: false } => password.to_string(),

            //A REGISTRATION MEANS THE ACCOUNT IS GONE - ASK
            _ => return None,
        };

        self.answers -= 1;

        Some(answer)
    }
}

impl Default for Login
{
    fn default() -> Self { Self::new() }
}

impl Login
{
    pub fn new() -> Self
    {
        let mut input = InputBuffer::new();

        //auto_connect IS THE ONE CASE THAT PREFILLS
        let auto = config::read_config::<bool>("auto_connect");
        if auto { input.insert_str(config::read_config::<String>("auto_connect_addr").trim()); }

        Self { input, stage: Stage::Address, busy: auto, connected: false, error: None, hint: None, attempt: 0 }
    }

    //COME BACK AT THE ADDRESS STEP AFTER A DROP
    pub fn again(address: &str, attempt: u64, error: String) -> Self
    {
        let mut input = InputBuffer::new();
        input.insert_str(address);

        Self { input, stage: Stage::Address, busy: false, connected: false, error: Some(error), hint: None, attempt }
    }

    pub fn address(&self) -> String { self.input.text().trim().to_owned() }

    pub fn attempt(&self) -> u64 { self.attempt }

    //THE ATTEMPT A RESULT HAS TO BELONG TO
    pub fn accepts(&self, attempt: u64) -> bool { self.busy && attempt == self.attempt }

    pub fn failed(&mut self, error: &Error)
    {
        self.busy = false;
        self.error = Some(error.to_string());
    }

    //ASK THE NEXT STEP, KEEPING THE ERROR
    pub fn ask(&mut self, stage: Stage, hint: Option<String>)
    {
        self.stage = stage;
        self.hint = hint;
        self.busy = false;
        self.input = InputBuffer::new();
    }

    pub fn masked(&self) -> bool { matches!(self.stage, Stage::Password { .. }) }

    pub fn title(&self) -> &'static str
    {
        match self.stage
        {
            Stage::Address => " Connect ",
            Stage::Username => " Identify ",
            Stage::Password { register: true } => " Register ",
            Stage::Password { register: false } => " Log in ",
        }
    }

    pub fn label(&self) -> &'static str
    {
        match self.stage
        {
            Stage::Address => "Server address",
            Stage::Username => "Username",
            Stage::Password { .. } => "Password",
        }
    }

    //THE STATUS ROW WHILE SOMETHING IS IN FLIGHT
    pub fn waiting(&self) -> &'static str
    {
        match (self.stage, self.connected)
        {
            (Stage::Address, false) => "Connecting…",
            (Stage::Address, true) => "Exchanging keys…", //THE SOCKET IS UP, THE HANDSHAKE IS NOT DONE
            _ => "Waiting for the server…",
        }
    }

    //ESC ABANDONS A DIAL, THEN LEAVES THE CLIENT
    pub fn cancellable(&self) -> bool { self.busy && !self.connected && self.stage == Stage::Address }
}

//FUNCTIONS
//PUBLIC
pub fn handle_key(app: &mut App, key: KeyEvent) -> Action
{
    let Some(login) = app.login.as_mut() else { return Action::None };

    //ESC BACKS OUT OF A DIAL FIRST
    if key.code == KeyCode::Esc
    {
        if login.connected || login.stage != Stage::Address || !login.busy { return Action::Quit; }

        //LEAVE THE TASK - ITS RESULT NO LONGER COUNTS
        login.busy = false;
        login.error = None;

        //A CANCELLED DIAL IS NOT ONE TO REPEAT
        app.reconnect.forget();

        return Action::None;
    }

    if login.busy { return Action::None; } //NOTHING IS EDITABLE WHILE AN ANSWER IS IN FLIGHT

    if key.modifiers.contains(KeyModifiers::CONTROL)
    {
        match key.code
        {
            KeyCode::Char('a') => login.input.home(),
            KeyCode::Char('e') => login.input.end(),
            KeyCode::Char('u') => login.input.kill_to_start(),
            KeyCode::Char('k') => login.input.kill_to_end(),
            KeyCode::Char('w') => login.input.delete_word(),
            _ => {},
        }

        return Action::None;
    }

    match key.code
    {
        //ONE FIELD, ONE LINE
        KeyCode::Char(character) => login.input.insert(character),

        KeyCode::Backspace => login.input.backspace(),
        KeyCode::Delete => login.input.delete(),

        KeyCode::Left => login.input.left(),
        KeyCode::Right => login.input.right(),
        KeyCode::Home => login.input.home(),
        KeyCode::End => login.input.end(),

        KeyCode::Enter => match login.stage
        {
            Stage::Address =>
            {
                if login.address().is_empty()
                {
                    login.error = Some(String::from("Enter the address of a server."));
                } else { return Action::Connect; }
            },

            //A PASSWORD IS TAKEN AS TYPED
            _ =>
            {
                if login.input.text().is_empty()
                {
                    login.error = Some(format!("Enter a {}.", login.label().to_lowercase()));
                } else { return Action::Submit; }
            },
        },

        _ => {},
    }

    Action::None
}

pub fn insert_str(app: &mut App, text: &str) //A PASTE INTO WHICHEVER FIELD IS UP
{
    if let Some(login) = app.login.as_mut() && !login.busy
    {
        login.input.insert_str(&text.replace(['\r', '\n'], ""));
    }
}

//TAKE THE ANSWERED STEP OFF THE FIELD, GO BUSY
pub fn take_input(app: &mut App) -> String
{
    let Some(login) = app.login.as_mut() else { return String::new() };

    //ONLY THE ADDRESS IS TRIMMED HERE
    let text = login.input.text();
    let stage = login.stage;

    login.input = InputBuffer::new();
    login.error = None;
    login.hint = None;
    login.busy = true;

    //A RECONNECT REPLAYS THIS
    app.reconnect.remember(stage, &text);

    text
}

//DIAL IN A TASK, SO THE FRAME KEEPS DRAWING
pub fn connect(app: &mut App, results: &Sender<ConnectResult>)
{
    let Some(login) = app.login.as_mut() else { return };

    let display = login.address();
    if display.is_empty() { return; }

    login.busy = true;
    login.error = None;
    login.attempt += 1;

    let attempt = login.attempt;

    //KEEP THE ADDRESS AS TYPED FOR THE TITLE
    let mut address = display.clone();
    if !address.contains(':') { address.push_str(&format!(":{}", config::read_config::<u16>("default_port"))); }

    app.address = display;

    //THE RECONNECT AFTER PINNING DIALS THIS
    options::set_server_address(&address);

    //A NEW CONNECTION COUNTS FROM ZERO
    options::set_seq(0);
    options::set_server_seq(0);

    let results = results.clone();

    tokio::spawn(async move
    {
        let _ = results.send((attempt, client::connect(address).await)).await;
    });
}