let (rx_char_control, rx_char_handle) = characteristic_control();
let (tx_char_control, tx_char_handle) = characteristic_control();

let app = Application {
    services: vec![Service {
        uuid: SERVICE_UUID,
        primary: true,
        characteristics: vec![
            Characteristic {
                uuid: WRITE_CHARACTERISTIC_UUID,
                write: Some(CharacteristicWrite {
                    write: true,
                    //write_without_response: true,
                    method: CharacteristicWriteMethod::Io,
                    ..Default::default()
                }),
                control_handle: rx_char_handle,
                ..Default::default()
            },
            Characteristic {
                uuid: NOTIFY_CHARACTERISTIC_UUID,
                notify: Some(CharacteristicNotify {
                    notify: true,
                    method: CharacteristicNotifyMethod::Io,
                    ..Default::default()
                }),
                control_handle: tx_char_handle,
                ..Default::default()
            },
        ],
        ..Default::default()
    }],
    ..Default::default()
};
let app_handle = adapter.serve_gatt_application(app).await?;

println!("Echo service ready. Press enter to quit.");
let stdin = BufReader::new(tokio::io::stdin());
let mut lines = stdin.lines();

pin_mut!(rx_char_control);
pin_mut!(tx_char_control);

let mut reader_opt1: Option<CharacteristicReader> = None;
let mut writer_opt1: Option<CharacteristicWriter> = None;

let mut read_buf1 = Vec::new();

loop {
    tokio::select! {
        _ = lines.next_line() => break,
        evt = rx_char_control.next() => {
            match evt {
                Some(CharacteristicControlEvent::Write(req)) => {
                    read_buf1 = vec![0; req.mtu()];
                    reader_opt1 = Some(req.accept()?);
                },
                Some(CharacteristicControlEvent::Notify(_)) => break,
                None => break,
            }
        },
        evt = tx_char_control.next() => {
            match evt {
                Some(CharacteristicControlEvent::Notify(notifier)) => {
                    writer_opt1 = Some(notifier);
                    login_session.generate_token();
                },
                _ => break,
            }
        },
        read_res = async {
            match &mut reader_opt1 {
                Some(reader) if writer_opt1.is_some() => reader.read(&mut read_buf1).await,
                _ => future::pending().await,
            }
        } => {
            match read_res {
                Ok(0) => {
                    println!("Read stream ended");
                    reader_opt1 = None;
                }
                Ok(n) => {
                    handle_request(&mut read_buf1, n, &mut writer_opt1, &mut received_packets, &mut login_session).await;   
                }
                Err(err) => {
                    println!("Read stream error: {}", &err);
                    reader_opt1 = None;
                }
            }
        }            
    }
}