use std::fmt;
use std::io;
use std::num::ParseIntError;

#[derive(Debug)]
enum AppError {
    Io(io::Error),
    Parse(ParseIntError),
    NotFound(String),
    Custom(String),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::Io(e) => write!(f, "IO error: {}", e),
            AppError::Parse(e) => write!(f, "Parse error: {}", e),
            AppError::NotFound(name) => write!(f, "Not found: {}", name),
            AppError::Custom(msg) => write!(f, "Error: {}", msg),
        }
    }
}

impl std::error::Error for AppError {}

impl From<io::Error> for AppError {
    fn from(e: io::Error) -> Self { AppError::Io(e) }
}

impl From<ParseIntError> for AppError {
    fn from(e: ParseIntError) -> Self { AppError::Parse(e) }
}

fn read_number(path: &str) -> Result<i32, AppError> {
    let content = std::fs::read_to_string(path)?;  // io::Error → AppError
    let number = content.trim().parse()?;           // ParseIntError → AppError
    Ok(number)
}

[dependencies]
thiserror = "1"

use thiserror::Error;

#[derive(Error, Debug)]
enum AppError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),

    #[error("Parse error: {0}")]
    Parse(#[from] std::num::ParseIntError),

    #[error("Not found: {0}")]
    NotFound(String),

    #[error("Custom error: {0}")]
    Custom(String),
}

[dependencies]
anyhow = "1"

use anyhow::{Context, Result};

fn read_config(path: &str) -> Result<Config> {
    let content = std::fs::read_to_string(path)
        .context("Failed to read config file")?;

    let config: Config = serde_json::from_str(&content)
        .context("Failed to parse config")?;

    Ok(config)
}

use thiserror::Error;

#[derive(Error, Debug)]
enum ValidationError {
    #[error("字段 '{field}' 不能为空")]
    EmptyField { field: String },

    #[error("字段 '{field}' 长度必须在 {min} 到 {max} 之间")]
    LengthOutOfRange { field: String, min: usize, max: usize },

    #[error("值 {value} 不在有效范围内")]
    OutOfRange { value: i32 },
}

fn validate_username(name: &str) -> Result<(), ValidationError> {
    if name.is_empty() {
        return Err(ValidationError::EmptyField {
            field: "username".to_string(),
        });
    }
    if name.len() < 3 || name.len() > 20 {
        return Err(ValidationError::LengthOutOfRange {
            field: "username".to_string(),
            min: 3,
            max: 20,
        });
    }
    Ok(())
}

fn main() {
    match validate_username("") {
        Ok(()) => println!("有效"),
        Err(e) => println!("验证失败: {}", e),
    }
}