// #[tokio::main] Макрос с тегами `main` Функция, указывающая, что эта асинхронная программа из `Tokio` должна использовать программу.
#[tokio::main]
async fn main() {
    // Впервые создан один `TcpListener` Слушатель, привязанный к адресу "127.0.0.1:3000" начальство
    // Затем пройдите `await` Дождитесь завершения привязки прослушивателя
    // Если привязка не удалась, она пройдет `unwrap` Метод выдает ошибку.
    let listener = tokio::net::TcpListener::bind("127.0.0.1:3000")
        .await
        .unwrap();
    println!("listening on {}", listener.local_addr().unwrap());
    // делатьиспользовать `axum::serve` запускать Axum рамкаизсервер,
    //    Послушать предыдущее творение из `TcpListener`。
    // `app()` функциявозвращатьсяиздаодин `Router`
    //    Он определяет простой одиниз маршрут, который преобразует путь "/a" Карта для обработки функции `a_handler`。
    axum::serve(listener, app()).await.unwrap();
}

// Возврат один `Маршрутизатор`, который имеет только одно правило маршрутизации,
//    Воля "/a" путь, сопоставленный с `a_handler` иметь дело сфункция
fn app() -> Router {
    Router::new()
        .route("/a", get(a_handler))
}

// Один обработчик WebSocket, который будет отображать любое полученное сообщение.
// Определен как один обработчик WebSocket,
//   он получает один `WebSocketUpgrade` Параметр, указывающий обновление WebSocket.
async fn a_handler(ws: WebSocketUpgrade) -> Response {
    // настраиватьиспользовать ВоляWebSocketПосле обновленияизобъектперешел к `a_handle_socket` иметь дело сфункция。
    ws.on_upgrade(a_handle_socket)
}

async fn a_handle_socket(mut socket: WebSocket) {
    // делатьиспользовать while let цикл, продолжающийся с WebSocket Получайте сообщения в соединении. 
    // socket.recv().await Принимать сообщения асинхронно,Возврат один Result,
    // в Ok(msg) Указывает, что сообщение было успешно получено.
    while let Some(Ok(msg)) = socket.recv().await {
        //  делатьиспользовать if let Сопоставьте и определите, является ли полученное сообщение да текстовым сообщением.
        //  Сообщения WebSocket могут быть разных типов, здесь мы имеем дело только с текстовыми сообщениями.
        if let Message::Text(msg) = msg {
            // структураодинэхо-сообщение,Воляклиентотправлятьизсообщение содержитсуществоватьэхо-сообщениесередина。
            // Затем,делатьиспользовать socket.send метод Воляэхо-сообщениеотправлятьразклиент。
            // await Дождитесь завершения операции отправки.
            if socket
                .send(Message::Text(format!("You said: {msg}")))
                .await
                // исследовать send Операция да Нет возвращает ошибку.
                // Если при отправке сообщения произошла ошибка (например, соединение отключено),
                // Просто пройди break Выйдите из цикла и завершите функцию обработки.
                .is_err()
            {
                break;
            }
        }
    }
}

use actix::{Actor, StreamHandler};
use actix_web::{
  web, 
  App, 
  Error, 
  HttpRequest, 
  HttpResponse, 
  HttpServer
};
use actix_web_actors::ws;

/// Определить HTTP Actor
// один определяется как MyWs из структуры,этот ВоляиспользоватьделатьWebSocketизActix Actor。
// Actors да Actixрамка из модуля параллелизма, использовать для обработки асинхронных сообщений
struct MyWs;

// для MyWs Структура реализована Actor черта, указанная WebsocketContext делатьдляначальствотип контекста。
impl Actor for MyWs {
    type Context = ws::WebsocketContext<Self>;
}

/// Обработка сообщения ws::Message из обработчика
// для MyWs Структура реализована StreamHandler черта, обрабатывает сообщения в WebSocketсоединять.
impl StreamHandler<Result<ws::Message, ws::ProtocolError>> for MyWs {
    // Обработку полученных сообщений разного типа руководить. Например, для Ping сообщение, отправить Pong информацияделатьдлякольцоотвечать。
    fn handle(&mut self, msg: Result<ws::Message, ws::ProtocolError>, ctx: &mut Self::Context) {
        match msg {
            Ok(ws::Message::Ping(msg)) => ctx.pong(&msg),
            Ok(ws::Message::Text(text)) => ctx.text(text),
            Ok(ws::Message::Binary(bin)) => ctx.binary(bin),
            _ => (),
        }
    }
}

// один определен для асинхронной обработки HTTP-запросов.
async fn index(req: HttpRequest, stream: web::Payload) -> Result<HttpResponse, Error> {
    // ВоляWebSocketсоединятьобновление,И Воляпросить поручено MyWs Actor иметь дело с.
    let resp = ws::start(MyWs {}, &req, stream);
    println!("{:?}", resp);
    resp
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    //  Создано один HttpServer например, через App::new() Создать одинотвечатьиспользовать,// Здесь следует использовать только один маршрут,Воляпуть "/ws/" Карта для обработки функции index начальство。
    HttpServer::new(|| App::new().route("/ws/", web::get().to(index)))
        // Привязать сервер к адресу "127.0.0.1" и порт 8080。
        .bind(("127.0.0.1", 8080))?
        // запускатьсервери Подождите, пока он завершит работу。
        .run()
        .await
}

// один определяется как Password из структуры, которая выводит Debug и FromForm traits。
// FromForm trait use используется для извлечения данных из данных формы.
// Эта структура содержит два поля first и второй соответственно представляет собой вторую часть пароля из одини.
#[derive(Debug, FromForm)]
struct Password<'v> {
    // Представляет пару полейиздлинаруководить Понятнопроверять,Требоватьдлинасуществовать6символы, начинающиеся сначальство
    #[field(validate = len(6..))]
    // Указывает, что одно поле должно быть равно второму полю.
    #[field(validate = eq(self.second))]
    first: &'v str,
    //  Указывает, что второе поле должно быть равно одиночному полю.
    #[field(validate = eq(self.first))]
    second: &'v str,
}

// Опустите другие структуры и реализуйте...

// one обрабатывает запросы GET для определенной функции index,Возврат один Template объект.
// Эта функцияиспользовать используется для отображения домашней страницы.
#[get("/")]
fn index() -> Template {
    Template::render("index", &Context::default())
}

// one обрабатывает POST-запросы из-за определенной функции submit。
// Эта функция принимает один Form объект,в Включать Понятноформаизданные
#[post("/", data = "<form>")]
fn submit(form: Form<Submit<'_>>) -> (Status, Template) {
    // проходитьисследовать form.value да Содержит ли он Some(ref submission) Чтобы определить, отправлена ​​ли форма.
    let template = match form.value {
        // Если форма отправлена, распечатайте отправленное содержимое и отобразите его. "success" страница;
        Some(ref submission) => {
            println!("submission: {:#?}", submission);
            Template::render("success", &form.context)
        }
        // В противном случае визуализируйте "index" страница.
        None => Template::render("index", &form.context),
    };

    (form.context.status(), template)
}

// определение ПонятнозапускатьRocketотвечатьиспользоватьпрограммаизфункция。
#[launch]
fn rocket() -> _ {
    // делатьиспользовать rocket::build() Создать экземпляр приложения OneRocket, использовать экземпляр программы
    rocket::build()
        // и пройти .mount() Способ монтирования маршрутов.
        // routes![index, submit] Определены два маршрута,
        // соответственно сопоставлено с index и submit функция。
        .mount("/", routes![index, submit])
        // Добавлена ​​обработка одного шаблона изFairing (изmiddleware в Rocket)
        .attach(Template::fairing())
        // Волястатические файлы Служитьмонтировать накореньпуть。
        .mount("/", FileServer::from(relative!("/static")))
}

// определен одинстатикизированный атом usize прилавок,использовать Вдлякаждыйсоединятьизиспользовать Распределение счетов уникальноизиспользоватьсемьяID。
static NEXT_USER_ID: AtomicUsize = AtomicUsize::new(1);

// текущийсоединятьиспользоватьсемьяизсостояние。
//  определен один псевдоним типа Пользователи, это даодин атомарный кавычек использовать счетчик нечитаемой блокировки записи HashMap,ВоляиспользоватьсемьяIDкарта к сообщениюизотправлятьустройство。
// Arc ссылка на даатом использует счетчик интеллектуальных указателей, RwLock да блокировка чтения-записи.
// - идентификатор ключа
// - Значение da`warp::ws::Message`изsender
type Users = Arc<RwLock<HashMap<usize, mpsc::UnboundedSender<Message>>>>;

#[tokio::main]
async fn main() {
    // Создано один users Переменная,use используется для хранения информации о пользователе.
    let users = Users::default();
    // Воляит упакован как Warp Фильтруйте так, чтобы различные маршруты существовали совместно с использованием статуса пользователя.
    let users = warp::any().map(move || users.clone());

    // chat обработка маршрутизации WebSocket рукопожатие
    let chat = warp::path("chat")
        // `ws()`фильтр Воля ПодготовитьWebSocketрукопожатие...
        .and(warp::ws())
        .and(users)
        // настраиватьиспользовать user_connected функцияиметь дело с WebSocket соединять。
        .map(|ws: warp::ws::Ws, users| {
            // еслирукопожатиеуспех,Волянастраиватьиспользоватьяихизфункция。
            ws.on_upgrade(move |socket| user_connected(socket, users))
        });

    // иметь дело с HTTP GET просить,Возврат один Содержит ссылку на чат HTML страница
    let index = warp::path::end().map(|| warp::reply::html(INDEX_HTML));

    let routes = index.or(chat);

    warp::serve(routes).run(([127, 0, 0, 1], 3030)).await;
}


async fn user_connected(ws: WebSocket, users: Users) {
    // делатьиспользоватьприлавокдляэтотиспользоватьсемьявыделить новыеизтолькоID。
    let my_id = NEXT_USER_ID.fetch_add(1, Ordering::Relaxed);

    eprintln!("new chat user: {}", my_id);

    // Воляраскол розеткидляинформацияизотправлятьустройствоиполучатель。
    let (mut user_ws_tx, mut user_ws_rx) = ws.split();
    // Создать новый канал сообщений (mpsc::unbounded_channel) использовать ВВоляиспользоватьсемьяизинформация Трансляция другимиспользоватьсемья
    let (tx, rx) = mpsc::unbounded_channel();
    let mut rx = UnboundedReceiverStream::new(rx);

    tokio::task::spawn(async move {
        // Постоянно получать сообщения. Этот цикл будет завершен, как только пользователь отключится.
        while let Some(message) = rx.next().await {
            user_ws_tx
                .send(message)
                .unwrap_or_else(|e| {
                    eprintln!("websocket send error: {}", e);
                })
                .await;
        }
    });

    //Воляотправлятьустройстводержатьсуществоватьяихизужесоединятьиспользоватьсемьясписоксередина。
    users.write().await.insert(my_id, tx);

    // Возврат одинбазовыйначальстводауправлятьэтотидентификацияиспользоватьсемьясоединятьизсостояниемашинаиз“Future”。

    // в любое времяиспользоватьсемьяотправлятьинформациячас,Воляитс транслирует на
    // Все остальные используют домохозяйства...
    while let Some(result) = user_ws_rx.next().await {
        let msg = match result {
            Ok(msg) => msg,
            Err(e) => {
                eprintln!("websocket error(uid={}): {}", my_id, e);
                break;
            }
        };
        user_message(my_id, msg, &users).await;
    }

    // если бы толькоиспользоватьсемья Держатьсоединять,Поток user_ws_rx будет продолжаться дело с.Как только они отключатсоединять,Так...
    user_disconnected(my_id, &users).await;
}

// иметь дело сиспользоватьсемьяотправлятьизинформация。этопропустить нетекстинформация,Волятекстинформацияформатдля <User#ID>: Message,Затем Воляитс транслирует навседругойиспользоватьсемья。
async fn user_message(my_id: usize, msg: Message, users: &Users) {
    // Пропускать любые нетекстовые сообщения...
    let msg = if let Ok(s) = msg.to_str() {
        s
    } else {
        return;
    };

    let new_msg = format!("<User#{}>: {}", my_id, msg);

    // Приходитьсэтотиспользоватьсемьяизновыйинформация,Воля Чтоотправлять Даватьвседругойиспользоватьсемья（удалять Понятнотакой жеизuid）...
    for (&uid, tx) in users.read().await.iter() {
        if my_id != uid {
            if let Err(_disconnected) = tx.send(Message::text(new_msg.clone())) {
                // Передатчик был отключен для подключения, мы ввели код `user_disconnected`
                // Если будет выполнена еще одна миссия, делать здесь больше нечего.
            }
        }
    }
}

async fn user_disconnected(my_id: usize, users: &Users) {
    eprintln!("good bye user: {}", my_id);

    // Поток закрыт и поэтому удален из списка пользователей.
    users.write().await.remove(&my_id);
}

// async-std crate Обеспечить асинхронный main функция。это Возврат один Результат, указывающий на возможную ошибку.
#[async_std::main]
async fn main() -> Result<(), std::io::Error> {
    // делатьиспользовать femme crate Кай использовать цветной журнал. Эта даодинизированная библиотека журналирования делает вывод журнала более читабельным.
    femme::start();
    // Создать один Tide Пример приложения
    let mut app = tide::new();
    // Добавлено одно промежуточное программное обеспечение для журнала, позволяющее записывать запросы и ответы из информации журнала.
    app.with(tide::log::LogMiddleware::new());
    // добавить водинсессиясерединапромежуточное программное обеспечение,использовать Виметь дело сданные сеанса。этотвнутриделатьиспользовать Внутрижитьхранилище,и предоставьте один ключ (TIDE_SECRET),использовать для шифрования и проверки данных сеанса.
    app.with(tide::sessions::SessionMiddleware::new(
        tide::sessions::MemoryStore::new(),
        std::env::var("TIDE_SECRET")
            .ожидать(
                «Пожалуйста, укажите значение TIDE_SECRET в \
                      не менее 32 байтов для запуска этого примера",
            )
            .as_bytes(),
    ));
    // Добавляем один перед промежуточным программным обеспечением,этосуществоватьиметь дело спросить Доосуществлять。существоватьэтотвнутри,Ituse используется для увеличения количества посещений,хранилищесуществоватьсессиясередина。
    app.with(tide::utils::Before(
        |mut request: tide::Request<()>| async move {
            let session = request.session_mut();
            let visits: usize = session.get("visits").unwrap_or_default();
            session.insert("visits", visits + 1).unwrap();
            request
        },
    ));
    // определение Понятноодиниметь дело скорень Путь из запроса GET из маршрута. Этот маршрут проходит async move Приходитьиметь дело спросить,Получить количество доступов в сеансе,и Возврат один содержит количество посещений из строки.
    app.at("/").get(|req: tide::Request<()>| async move {
        let visits: usize = req.session().get("visits").unwrap();
        Ok(format!("you have visited this website {} times", visits))
    });
    // определение Понятноодиниметь дело с "/reset" Путь из запроса GET из маршрута. Этот маршрут проходит async move иметь дело спросить,Воляданные сеанса清удалять,Затемперенаправить накореньпуть
    app.at("/reset")
        .get(|mut req: tide::Request<()>| async move {
            req.session_mut().destroy();
            Ok(tide::Redirect::new("/"))
        });
    // запускатьотвечатьиспользоватьпрограммаимониторсуществовать "127.0.0.1:8080" адресначальство。делатьиспользовать await? иметь дело возможно неправильно иззапускаю.
    app.listen("127.0.0.1:8080").await?;

    Ok(())
}

// 注развязать表示этотдаодиниметь дело сустройствофункция,использовать Виметь дело с WebSocket просить
#[handler]
fn ws(
    // Извлечено WebSocket параметр isname в пути
    Path(name): Path<String>,
    // WebSocket объект, представление и клиент изоединять
    ws: WebSocket,
    // даодин экстрактор данных, используемый для получения канала вещания с передатчика.
    sender: Data<&tokio::sync::broadcast::Sender<String>>,
) -> impl IntoResponse {
    // Клонировать канал вещания из передатчика sender。
    let sender = sender.clone();
    // этоподписка Понятновещательный канал,Создано одинполучатель receiver
    let mut receiver = sender.subscribe();
    //  иметь дело с WebSocket соединятьобновление    ws.on_upgrade(move |socket| async move {
        // Волясоединятьиз разделения чтения и письма для sink и stream
        let (mut sink, mut stream) = socket.split();
        
        // от WebSocket Клиент получает сообщение
        // еслидатекстинформация,Потом Воля его форматировал под {name}: {text} изформа,и пройтивещательный каналотправлять。
        // Если отправка не удалась (например, канал закрыт), задача завершается.

        tokio::spawn(async move {
            while let Some(Ok(msg)) = stream.next().await {
                if let Message::Text(text) = msg {
                    if sender.send(format!("{name}: {text}")).is_err() {
                        break;
                    }
                }
            }
        });
        // отвещательный канал接收информация,и Воля Чтоотправлятьприезжать WebSocket клиент
        tokio::spawn(async move {
            while let Ok(msg) = receiver.recv().await {
                if sink.send(Message::Text(msg)).await.is_err() {
                    break;
                }
            }
        });
    })
}

#[tokio::main]
async fn main() -> Result<(), std::io::Error> {
    // делатьиспользовать tide::Route Создано одинмаршрутизация,ввключает в себя двапуть：
    // - / путьиметь дело с HTTP GET просить,настраиватьиспользовать index функция。
    // - /ws/:name путьиметь дело с WebSocket просить,настраиватьиспользовать ws функция。
    let app = Route::new().at("/", get(index)).at(
        "/ws/:name",
        // проходить tokio::sync::broadcast::channel Создать один канал вещания;
        // и пройти tokio::sync::broadcast::channel::<String>(32).0 
        //   获取Чтоотправлятьустройство,Воля Чтоделатьдляданные передаются в ws иметь дело сфункция
        get(ws.data(tokio::sync::broadcast::channel::<String>(32).0)),
    );
    // Создано одинсервер Примеры
    Server::new(TcpListener::bind("127.0.0.1:3000"))
         // запускатьсервер,и дождитесь завершения работы.
        .run(приложение)
        .жду
}