struct Command {
    keyword: String,
    args: Vec<String>,
}
fn main() {
    let mut c: String = String::from("test \"one two\" three");
    let cmd: Vec<String> = c.split_whitespace().map(|s| s.to_string()).collect();
    
    let command: Command = search_quotes(cmd);
}
fn search_quotes(c: Vec<String>) -> Command {
    // Here I need the elements enclosed in quotes to unite in one element.
    // Prosice data for the withdrawal in this example below
    Command {
        keyword: "test",
        args: ["\"one two\"", "three"]
    }
}

let cmd = vec!["test", "\"one", "two\"", "three"];
let mut n: Vec<usize> = vec![];
    for i in 0..cmd.len() {
        let bytes = cmd[i+1].as_bytes();
        for (j, &item) in bytes.iter().enumerate() {
            if item == b'"' {
                if j == 0 || j == bytes.len()-1 {
                    let n = n.push(i+1);
                }
            }
        }
    }

fn search_quotes(mut c: Vec<String>) -> Command {
    let mut i = 0;
    let mut has_quote = false;
    while i < c.len() {
        if has_quote {
            let s = c.remove(i);
            let s = if s.ends_with('"') {
                has_quote = false;
                &s[..s.len() - 1]
            } else {
                &s
            };
            c[i - 1].push(' ');
            c[i - 1].push_str(s);
        } else {
            if c[i].starts_with('"') {
                c[i].replace_range(..1, "");
                if c[i].ends_with('"') {
                    let quote = c[i].len() - 1;
                    c[i].replace_range(quote.., "");
                } else {
                    has_quote = true;
                }
            }
            
            i += 1;
        }
    }
    
    if has_quote {
        panic!("unmatched quote");
    }
    
    Command {
        keyword: c.remove(0),
        args: c,
    }
}