#Bool 类型 - Boolean Types

// 声明布尔变量
var isActive bool = true
var isVerified bool = false

// 类型推断
enabled := true
disabled := false

// 零值为 false
var defaultValue bool  // false

var b bool
fmt.Println(b == false)  // true
fmt.Println(b)           // false

a := true
b := false

// 逻辑非（NOT）
fmt.Println(!a)  // false

// 逻辑与（AND）
fmt.Println(a && b)  // false

// 逻辑或（OR）
fmt.Println(a || b)  // true

// 优先级：! > && > ||
result := true || false && false  // true（先算 &&）
fmt.Println(result)

// 建议使用括号明确优先级
result = true || (false && false)  // 更清晰

// 比较运算返回 bool 值
fmt.Println(10 > 5)    // true
fmt.Println(5 == 5)    // true
fmt.Println(3 != 3)    // false
fmt.Println(7 >= 7)    // true

type User struct {
    IsActive    bool
    IsVerified  bool
    HasPermission bool
}

user := User{
    IsActive:    true,
    IsVerified:  false,
    HasPermission: true,
}

// 条件检查
if user.IsActive && user.IsVerified {
    fmt.Println("用户已激活且已验证")
}

type Config struct {
    Debug      bool
    Logging    bool
    CacheEnabled bool
}

config := Config{
    Debug:      true,
    Logging:    false,
    CacheEnabled: true,
}

if config.Debug {
    fmt.Println("Debug 模式已开启")
}

// 判断是否为偶数
func isEven(n int) bool {
    return n%2 == 0
}

// 验证邮箱格式
func isValidEmail(email string) bool {
    return strings.Contains(email, "@")
}

// 检查权限
func hasPermission(user User, resource string) bool {
    return user.IsActive && user.HasPermission
}

if isEven(10) {
    fmt.Println("10 是偶数")
}

isActive := true

// 简洁形式
if isActive {
    fmt.Println("激活状态")
}

// 带否定的形式
if !isActive {
    fmt.Println("未激活")
}

// 多条件
if isActive && isVerified {
    fmt.Println("激活且已验证")
}

// ❌ Go 没有三元运算符
// result := condition ? value1 : value2

// ✅ 使用 if-else
var result string
if condition {
    result = value1
} else {
    result = value2
}

// ✅ 好：使用 is/has/can 前缀
var isActive bool
var hasPermission bool
var canWrite bool
var shouldRetry bool

// ❌ 差：命名不清晰
var active bool
var permission bool

// ❌ 差：多个 bool 参数难以理解
func process(enabled, verbose, debug bool) {
    // enabled 是什么？verbose 影响什么？
}

// ✅ 好：使用选项模式
type Options struct {
    Enabled bool
    Verbose bool
    Debug   bool
}

func process(opts Options) {
    if opts.Enabled && opts.Verbose {
        // ...
    }
}

// 调用更清晰
process(Options{
    Enabled: true,
    Verbose: true,
    Debug:   false,
})

// ❌ 差：只知道失败，不知道原因
func isValid(data string) bool {
    return len(data) > 0
}

// ✅ 好：返回 bool 和错误信息
func validate(data string) (bool, error) {
    if len(data) == 0 {
        return false, errors.New("data cannot be empty")
    }
    return true, nil
}

if valid, err := validate(data); !valid {
    fmt.Println("验证失败:", err)
}

// ❌ Go 不允许非布尔值在条件中
// if 1 {  // 编译错误
//     fmt.Println("true")
// }

// ✅ 必须使用布尔表达式
if 1 > 0 {
    fmt.Println("true")
}

// ❌ 不能将整数转换为 bool
// n := 1
// if n {  // 编译错误
// }

// ✅ 需要显式比较
if n != 0 {
    fmt.Println("非零")
}

type Result struct {
    Success bool
}

var r *Result  // nil 指针

// 检查指针是否为 nil
if r == nil {
    fmt.Println("结果不存在")
}

// 检查 bool 字段（需要先检查指针）
if r != nil && r.Success {
    fmt.Println("操作成功")
}

// 使用 bool 指针表示"三种状态"
type User struct {
    IsDeleted *bool  // nil=未设置, true=已删除, false=未删除
}

// 通常更好的做法是使用枚举
type DeleteStatus int

const (
    DeleteStatusUnknown DeleteStatus = iota
    DeleteStatusActive
    DeleteStatusDeleted
)

type User struct {
    DeleteStatus DeleteStatus
}

// 定义条件接口
type Condition interface {
    Evaluate() bool
}

// 具体条件
type AgeCondition struct {
    MinAge int
}

func (c AgeCondition) Evaluate() bool {
    return time.Now().Year() - c.BirthYear >= c.MinAge
}

// 使用
conditions := []Condition{
    AgeCondition{MinAge: 18},
    // ...
}

for _, cond := range conditions {
    if cond.Evaluate() {
        fmt.Println("条件满足")
    }
}