#[tokio::main]
async fn test_http() -> Result<(), Box<dyn std::error::Error>> {
    let body = reqwest::get("https://www.rust-lang.org")
        .await?
        .text()
        .await?;

    println!("body = {body:?}");
    Ok(())
}

//--

async fn get_url_text(url: &str) -> Result<String, Box<dyn std::error::Error>> {
    let body = reqwest::get(url).await?.text().await?;
    //println!("body = {body:?}");
    Ok(body)
}

//Create an HTTP request:

use http::Request;

fn main() {
    let request = Request::builder()
      .uri("https://www.rust-lang.org/")
      .header("User-Agent", "awesome/1.0")
      .body(())
      .unwrap();
}

//--

//Create an HTTP response:

use http::{Response, StatusCode};

fn main() {
    let response = Response::builder()
      .status(StatusCode::MOVED_PERMANENTLY)
      .header("Location", "https://www.rust-lang.org/install.html")
      .body(())
      .unwrap();
}

use tower_http::{
    decompression::DecompressionLayer,
    set_header::SetRequestHeaderLayer,
    trace::TraceLayer,
    classify::StatusInRangeAsFailures,
};
use tower::{ServiceBuilder, Service, ServiceExt};
use hyper_util::{rt::TokioExecutor, client::legacy::Client};
use http_body_util::Full;
use bytes::Bytes;
use http::{Request, HeaderValue, header::USER_AGENT};

#[tokio::main]
async fn main() {
let client = Client::builder(TokioExecutor::new()).build_http();
    let mut client = ServiceBuilder::new()
        // Add tracing and consider server errors and client
        // errors as failures.
        .layer(TraceLayer::new(
            StatusInRangeAsFailures::new(400..=599).into_make_classifier()
        ))
        // Set a `User-Agent` header on all requests.
        .layer(SetRequestHeaderLayer::overriding(
            USER_AGENT,
            HeaderValue::from_static("tower-http demo")
        ))
        // Decompress response bodies
        .layer(DecompressionLayer::new())
        // Wrap a `Client` in our middleware stack.
        // This is possible because `Client` implements
        // `tower::Service`.
        .service(client);

    // Make a request
    let request = Request::builder()
        .uri("http://example.com")
        .body(Full::<Bytes>::default())
        .unwrap();

    let response = client
        .ready()
        .await
        .unwrap()
        .call(request)
        .await
        .unwrap();
}

#[allow(dead_code)]
pub async fn start_serve() {
    // initialize tracing
    tracing_subscriber::fmt::try_init().ok();

    // build our application with a route
    let app = Router::new()
        // `GET /` goes to `root`
        .route("/", any(root))
        // `POST /json` goes to `create_user`
        .route("/json", post(post_json));

    // run our app with hyper, listening globally on port 9292
    let addr = "0.0.0.0:9292";
    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
    log::info!("listening on {addr}");
    axum::serve(listener, app).await.unwrap();
}

// basic handler that responds with a static string
#[allow(dead_code)]
async fn root() -> String {
    format!("Hello, Axum! {}", now_date_time())
}
#[allow(dead_code)]
async fn post_json(
    // this argument tells axum to parse the request body
    // as JSON into a `CreateUser` type
    Json(payload): Json<HashMap<String, serde_json::Value>>,
) -> (StatusCode, Json<HashMap<String, serde_json::Value>>) {
    // this will be converted into a JSON response
    // with a status code of `201 Created`
    let mut result: HashMap<String, serde_json::Value> = HashMap::new();
    result.extend(payload);
    result.insert(
        "reply".to_string(),
        serde_json::Value::String(now_date_time()),
    );
    (StatusCode::CREATED, Json(result))
}

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    // Convert the Point to a JSON string.
    let serialized = serde_json::to_string(&point).unwrap();

    // Prints serialized = {"x":1,"y":2}
    println!("serialized = {}", serialized);

    // Convert the JSON string back to a Point.
    let deserialized: Point = serde_json::from_str(&serialized).unwrap();

    // Prints deserialized = Point { x: 1, y: 2 }
    println!("deserialized = {:?}", deserialized);
}

{
    "name": "John Doe",
    "age": 43,
    "address": {
        "street": "10 Downing Street",
        "city": "London"
    },
    "phones": [
        "+44 1234567",
        "+44 2345678"
    ]
}

//--

let p: Person = serde_json::from_str(data)?;

// Serialize it to a JSON string.
let j = serde_json::to_string(&address)?;

//--

serde_json::Value::String(now_date_time());

let mut result: HashMap<String, serde_json::Value> = HashMap::new();

// initialize tracing
tracing_subscriber::fmt::init();

#[tokio::main]
async fn test_http() -> Result<(), Box<dyn std::error::Error>> {
    let body = reqwest::get("https://www.rust-lang.org")
        .await?
        .text()
        .await?;

    println!("body = {body:?}");
    Ok(())
}

//--

async fn get_url_text(url: &str) -> Result<String, Box<dyn std::error::Error>> {
    let body = reqwest::get(url).await?.text().await?;
    //println!("body = {body:?}");
    Ok(body)
}

#[tokio::main]
#[allow(arithmetic_overflow)]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    //test_macro();

    let url = "https://www.rust-lang.org";
    let output = ".output/rust.md";

    let body = get_url_text(url).await?;

    // Create output directory
    let output_dir = std::path::Path::new(output).parent().unwrap();
    if !output_dir.exists() {
        std::fs::create_dir_all(output_dir).unwrap();
    }
    println!("Converting html to markdown...");
    let md = html2md::parse_html(&body);
    std::fs::write(output, md.as_bytes()).unwrap();
    println!("Converted markdown has been saved in {}.", output);
    Ok(())
}

use clap::Parser;

/// Simple program to greet a person
#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Args {
    /// Name of the person to greet
    #[arg(short, long)]
    name: String,

    /// Number of times to greet
    #[arg(short, long, default_value_t = 1)]
    count: u8,
}

fn main() {
    let args = Args::parse();

    for _ in 0..args.count {
        println!("Hello {}!", args.name);
    }
}

extern crate colored; // not needed in Rust 2018+

use colored::Colorize;

// test the example with `cargo run --example most_simple`
fn main() {
    // TADAA!
    println!("{} {} !", "it".green(), "works".blue().bold());
}

extern crate jsonxf;
let ugly_json = "{\"hello\":\"world\"}";
let pretty_json = jsonxf::pretty_print(ugly_json).unwrap();
assert_eq!(pretty_json, "{\n  \"hello\": \"world\"\n}\n");

extern crate mime;

// common types are constants
let text = mime::TEXT_PLAIN;

// deconstruct Mimes to match on them
match (text.type_(), text.subtype()) {
    (mime::TEXT, mime::PLAIN) => {
        // plain text!
    },
    (mime::TEXT, _) => {
        // structured text!
    },
    _ => {
        // not text!
    }
}

use chrono::prelude::*;

let utc: DateTime<Utc> = Utc::now(); // e.g. `2014-11-28T12:45:59.324310806Z`

//--

use chrono::prelude::*;

let local: DateTime<Local> = Local::now(); // e.g. `2014-11-28T21:45:59.324310806+09:00`

use anyhow::Result;

fn get_cluster_info() -> Result<ClusterMap> {
    let config = std::fs::read_to_string("cluster.json")?;
    let map: ClusterMap = serde_json::from_str(&config)?;
    Ok(map)
}

use log::info;

fn main() {
    env_logger::init();

    info!("starting up");

    // ...
}

// Quick start: use default initialization
colog::init();

log::error!("error message");
log::error!("error with fmt: {}", 42);
log::warn!("warn message");
log::info!("info message");
log::debug!("debug message");
log::trace!("trace message");

//--

[E] error message
[E] error with fmt: 42
[W] warn message
[*] info message

SimpleLogger::new().init().unwrap();

log::error!("error message");
log::error!("error with fmt: {}", 42);
log::warn!("warn message");
log::info!("info message");
log::debug!("debug message");
log::trace!("trace message");

//--

2025-05-23T03:26:21.648Z ERROR [rust_study::utils] error message
2025-05-23T03:26:21.648Z ERROR [rust_study::utils] error with fmt: 42
2025-05-23T03:26:21.648Z WARN  [rust_study::utils] warn message
2025-05-23T03:26:21.648Z INFO  [rust_study::utils] info message
2025-05-23T03:26:21.648Z DEBUG [rust_study::utils] debug message
2025-05-23T03:26:21.648Z TRACE [rust_study::utils] trace message

/// 将字节数组进行base64加密
#[allow(dead_code)]
pub fn base64_encode(bytes: &[u8]) -> String {
    STANDARD.encode(bytes)
}

/// 将base64的字符串进行解密
#[allow(dead_code)]
pub fn base64_decode(s: &str) -> Result<Vec<u8>, DecodeError> {
    STANDARD.decode(s)
}

/// 将字节数组进行md5加密
#[allow(dead_code)]
pub fn md5_encode(bytes: &[u8]) -> String {
    format!("{:X}", md5::compute(bytes))
}

/// 生成一个uuid
#[allow(dead_code)]
pub fn uuid() -> String {
    uuid::Uuid::new_v4().to_string().to_uppercase().replace("-", "")
}

/// 随机生成一个浮点数
#[allow(dead_code)]
pub fn random_f64() -> f64 {
    let mut rng = rand::rng();
    rng.random()
}

/// 在一个范围内随机
/// `random_range(0..100)`
#[allow(dead_code)]
pub fn random_range<T, R>(range: R) -> T
where
    T: SampleUniform,
    R: SampleRange<T>,
{
    let mut rng = rand::rng();
    rng.random_range(range)
}

use bytes::{BytesMut, BufMut};

let mut buf = BytesMut::with_capacity(1024);
buf.put(&b"hello world"[..]);
buf.put_u16(1234);

let a = buf.split();
assert_eq!(a, b"hello world\x04\xD2"[..]);

buf.put(&b"goodbye world"[..]);

let b = buf.split();
assert_eq!(b, b"goodbye world"[..]);

assert_eq!(buf.capacity(), 998);

use is_terminal::IsTerminal;

fn main() {
    if std::io::stdout().is_terminal() {
        println!("Stdout is a terminal");
    } else {
        println!("Stdout is not a terminal");
    }
}

use std::io::{self, Write};
use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};

fn write_green() -> io::Result<()> {
    let mut stdout = StandardStream::stdout(ColorChoice::Always);
    stdout.set_color(ColorSpec::new().set_fg(Some(Color::Green)))?;
    writeln!(&mut stdout, "green text!")
}

use pdfium_render::prelude::*;

fn export_pdf_to_jpegs(path: &impl AsRef<Path>, password: Option<&str>) -> Result<(), PdfiumError> {
    // Renders each page in the PDF file at the given path to a separate JPEG file.

    // Bind to a Pdfium library in the same directory as our Rust executable.
    // See the "Dynamic linking" section below.

    let pdfium = Pdfium::default();

    // Load the document from the given path...

    let document = pdfium.load_pdf_from_file(path, password)?;

    // ... set rendering options that will be applied to all pages...

    let render_config = PdfRenderConfig::new()
        .set_target_width(2000)
        .set_maximum_height(2000)
        .rotate_if_landscape(PdfPageRenderRotation::Degrees90, true);

    // ... then render each page to a bitmap image, saving each image to a JPEG file.

    for (index, page) in document.pages().iter().enumerate() {
        page.render_with_config(&render_config)?
            .as_image() // Renders this page to an image::DynamicImage...
            .into_rgb8() // ... then converts it to an image::Image...
            .save_with_format(
                format!("test-page-{}.jpg", index), 
                image::ImageFormat::Jpeg
            ) // ... and saves it to a file.
            .map_err(|_| PdfiumError::ImageError)?;
    }

    Ok(())
}

use pdf2image::{PDF2ImageError, RenderOptionsBuilder, PDF};

fn main() -> Result<(), PDF2ImageError> {
    let pdf = PDF::from_file("examples/pdfs/ropes.pdf").unwrap();
    let pages = pdf.render(
        pdf2image::Pages::Range(1..=8),
        RenderOptionsBuilder::default().pdftocairo(true).build()?,
    )?;

    std::fs::create_dir("examples/out").unwrap();
    for (i, page) in pages.iter().enumerate() {
        page.save_with_format(format!("examples/out/{}.jpg", i + 1), image::ImageFormat::Jpeg)?;
    }

    Ok(())
}

pub async fn send_mail_lettre(
    from: (String, String),
    to: (String, String),
    title: &str,
    html_body: &str,
    text_body: &str,
    //--
    host: (&str, u16),
    credentials: (&str, &str),
) {
    let email = Message::builder()
        .from(format!("{} <{}>", from.0, from.1).parse().unwrap())
        //.reply_to(format!("{} <{}>", from.0, from.1).parse().unwrap())
        .to(format!("{} <{}>", to.0, to.1).parse().unwrap())
        .subject(title)
        .header(ContentType::TEXT_HTML)
        .body(if html_body.is_empty() {
            text_body.to_string()
        } else {
            html_body.to_string()
        })
        .unwrap();

    let creds = Credentials::new(credentials.0.to_owned(), credentials.1.to_owned());

    // Open a remote connection to gmail
    let mailer = SmtpTransport::relay(host.0)
        .unwrap()
        .credentials(creds)
        .build();

    // Send the email
    mailer.send(&email).unwrap();
}

//--

#[allow(dead_code)]
async fn test_send_mail() {
    mail::send_mail_lettre(
        ("no-reply".to_string(), "no-reply@laserabc.com".to_string()),
        ("angcyo".to_string(), "angcyo@126.com".to_string()),
        format!("title - {}", utils::now_timestamp()).as_str(),
        format!("<h1>Hello, body. <sup>html</sup>! {}</h1>", utils::now_date_time()).as_str(),
        format!("Hello body. <sup>text</sup>! {}", utils::now_date_time()).as_str(),
        ("smtp.feishu.cn", 465),
        ("no-reply@laserabc.com", ""),
    )
    .await;
}

pub async fn send_mail(
    from: (String, String),
    to: (String, String),
    title: &str,
    html_body: &str,
    text_body: &str,
    //--
    host: (&str, u16),
    credentials: (&str, &str),
) {
    // Build a simple multipart message
    let message = MessageBuilder::new()
        .from(from)
        .to(to)
        .subject(title)
        .html_body(html_body)
        .text_body(text_body);

    // Connect to the SMTP submissions port, upgrade to TLS and
    // authenticate using the provided credentials.
    SmtpClientBuilder::new(host.0, host.1)
        .implicit_tls(false) //starttls or ssl
        .credentials(credentials)
        .timeout(std::time::Duration::from_secs(5))
        .connect()
        .await
        .unwrap()
        .send(message)
        .await
        .unwrap();
}

use lazy_static::lazy_static;
use std::collections::HashMap;

lazy_static! {
    static ref HASHMAP: HashMap<u32, &'static str> = {
        let mut m = HashMap::new();
        m.insert(0, "foo");
        m.insert(1, "bar");
        m.insert(2, "baz");
        m
    };
}

fn main() {
    // First access to `HASHMAP` initializes it
    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());

    // Any further access to `HASHMAP` just returns the computed value
    println!("The entry for `1` is \"{}\".", HASHMAP.get(&1).unwrap());
}

ImageReader::open(image_file_path)?.decode()
    .unwrap()
    .grayscale() // 灰度处理
    .save(".output/FaceQ_output.png")
    .unwrap();

extern crate photon_rs;
use photon_rs::native::{open_image, save_image};

fn main() {
    // Open the image (a PhotonImage is returned)
    let mut img = open_image("test_image.png");

    // Increment the red channel by 40
    photon_rs::channels::alter_red_channel(&mut img, 40);

    // Write file to filesystem.
    save_image(img, "raw_image.jpg");    
}

use lru::LruCache;
use std::num::NonZeroUsize;

fn main() {
    let mut cache = LruCache::new(NonZeroUsize::new(2).unwrap());
    cache.put("apple", 3);
    cache.put("banana", 2);

    assert_eq!(*cache.get(&"apple").unwrap(), 3);
    assert_eq!(*cache.get(&"banana").unwrap(), 2);
    assert!(cache.get(&"pear").is_none());

    assert_eq!(cache.put("banana", 4), Some(2));
    assert_eq!(cache.put("pear", 5), None);

    assert_eq!(*cache.get(&"pear").unwrap(), 5);
    assert_eq!(*cache.get(&"banana").unwrap(), 4);
    assert!(cache.get(&"apple").is_none());

    {
        let v = cache.get_mut(&"banana").unwrap();
        *v = 6;
    }

    assert_eq!(*cache.get(&"banana").unwrap(), 6);
}

#[allow(dead_code)]
pub fn test_protocol() {
    let shirt = shirt::Shirt {
        color: "blue".to_string(),
        size: 2,
    };
    // 将 Shirt 序列化为字节数组
    let mut buf = Vec::new();
    // let mut buf = vec![];
    shirt.encode(&mut buf).unwrap();

    crate::ptl!("Encoded shirt: {:?}", crate::utils::base64_encode(&buf));

    // 从字节数组反序列化为 Shirt 实例
    let decoded_shirt = shirt::Shirt::decode(&buf[..]).unwrap();

    // 输出反序列化出来的内容
    println!("Decoded shirt: {:?}", decoded_shirt);
}

// build.rs
fn main() -> std::io::Result<()> {
    prost_build::Config::new()
        .out_dir("src/protocol")
        .compile_protos(&["src/protocol/shirt.proto"], &["src/"])?;
    //prost_build::compile_protos(&["src/protocol/items.proto"], &["src/"])?;
    Ok(())
}