// 1. 值比较
type Book struct {
    Name   string
    Status int // 0-unavailable 1-available
}

if book.Status == 1 {
    /*do something*/
}

// 2. 别名
const (
    BOOK_STATUS_UNAVAILABLE = 0
    BOOK_STATUS_AVAILABLE   = 1
)

type Book struct {
    Name   string
    Status int
}

if book.Status == BOOK_STATUS_AVAILABLE {
    /*do something*/
}

// 3. 函数
const (
    BOOK_STATUS_UNAVAILABLE = 0
    BOOK_STATUS_AVAILABLE   = 1
)

type Book struct {
    Name   string
    Status int
}

func (b *Book) IsAvailable() bool {
    return b.Status == BOOK_STATUS_AVAILABLE
}

if book.IsAvailable() {
    /*do something*/
}

// 语境不明确的变量
private void printGuessStatistics(char candidate, int count) {
    String number;
    String pluralModifier;
    String verb;
    if (count == 0) {
        number = "no";
        pluralModifier = "s";
        verb = "are";
    } else if (count == 1) {
        number = "1";
        pluralModifier = "";
        verb = "is";
    } else {
        number = Integer.toString(count);
        verb = "are";
        pluralModifier = "s";
    }
    String guessMessage = String.format(
        "There %s %s %s%s", verb, number, candidate,pluralModifier
    );
    print(guessMessage);
}

// 有语境的变量
private void printGuessStatistics(char candidate, int count) {
    String number;
    String pluralModifier;
    String verb;

    public String make(char candidate, int count) {
        createPluralDependentMessageParts(count);
        return String guessMessage = String.format(
            "There %s %s %s%s", verb, number, candidate, pluralModifier
        );
    }

    private void createPluralDependentMessageParts(int count) {
        if (count == 0) {
            thereAreNoLetters();
        } else if (count == 1) {
            thereIsOneLetter();
        } else {
            thereAreManyLetters(count);
        }
    }

    private void thereAreManyLetters(int count) {
        number = Integer.toString(count);
        verb = "are";
        pluralModifier = "s";
    }

    private void thereIsOneLetter() {
        number = Integer.toString(count);
        verb = "are";
        pluralModifier = "s";
    }

    private void thereAreNoLetters() {
        number = "no";
        pluralModifier = "s";
        verb = "are";
    }

    print(guessMessage);
}

// 个人习惯

// 打印统计信息
private void printGuessStatistics(char candidate, int count) {
    String number;
    String pluralModifier;
    String verb;

    // 统计数量，分类处理
    if (count == 0) {
        // 没有
        number = "no";
        pluralModifier = "s";
        verb = "are";
    } else if (count == 1) {
        // 只有一个
        number = "1";
        pluralModifier = "";
        verb = "is";
    } else {
        // 有多个
        number = Integer.toString(count);
        verb = "are";
        pluralModifier = "s";
    }
    
    // 构造结果
    String guessMessage = String.format(
        "There %s %s %s%s", verb, number, candidate, pluralModifier
    );
    print(guessMessage);
}

// 问题：每次处理员工都要写 switch
type EmployeeType int

const (
    COMMISSIONED EmployeeType = iota  // 提成员工
    HOURLY                             // 时薪员工
    SALARIED                           // 月薪员工
)

// 计算薪资 - 这里有一个 switch
func CalculatePay(e Employee) int {
    switch e.Type {
    case COMMISSIONED:
        return calculateCommissionedPay(e)
    case HOURLY:
        return calculateHourlyPay(e)
    case SALARIED:
        return calculateSalariedPay(e)
    }
    return 0
}

// 判断是否是领班 - 又有一个 switch
func IsLead(e Employee) bool {
    switch e.Type {
    case COMMISSIONED:
        return isCommissionedLead(e)
    case HOURLY:
        return isHourlyLead(e)
    case SALARIED:
        return isSalariedLead(e)
    }
    return false
}

// 以后每加一个员工类型，要改所有 switch 函数

// 第一步：定义接口，所有员工都实现它
type Employee interface {
    CalculatePay() int
    IsLead() bool
    // 其他员工相关行为...
}

// 第二步：三种具体员工类型，各自实现接口
type CommissionedEmployee struct {
    // 提成员工的字段
}

func (e *CommissionedEmployee) CalculatePay() int {
    // 提成薪资算法
    return 0
}

func (e *CommissionedEmployee) IsLead() bool {
    // 提成员工判断领班的逻辑
    return false
}

type HourlyEmployee struct {
    // 时薪员工的字段
}

func (e *HourlyEmployee) CalculatePay() int {
    // 时薪算法
    return 0
}

func (e *HourlyEmployee) IsLead() bool {
    // 时薪员工判断领班的逻辑
    return false
}

type SalariedEmployee struct {
    // 月薪员工的字段
}

func (e *SalariedEmployee) CalculatePay() int {
    // 月薪算法
    return 0
}

func (e *SalariedEmployee) IsLead() bool {
    // 月薪员工判断领班的逻辑
    return false
}

// 第三步：工厂函数 - switch 只在这里出现一次！
func CreateEmployee(type EmployeeType) Employee {
    switch type {
    case COMMISSIONED:
        return &CommissionedEmployee{}
    case HOURLY:
        return &HourlyEmployee{}
    case SALARIED:
        return &SalariedEmployee{}
    }
    return nil
}

// 不好的写法
type Point struct {
    X float64  // 直接暴露
    Y float64
}

// 较好的写法（接口隐藏实现）
type Point interface {
    GetX() float64
    GetY() float64
    GetR() float64
    GetTheta() float64
}

// 内部实现可以是直角坐标
type cartesianPoint struct {
    x, y float64
}
func (p *cartesianPoint) GetX() float64     { return p.x }
func (p *cartesianPoint) GetY() float64     { return p.y }
func (p *cartesianPoint) GetR() float64     { return math.Hypot(p.x, p.y) }
func (p *cartesianPoint) GetTheta() float64 { return math.Atan2(p.y, p.x) }

// 也可以换成极坐标实现，调用方完全无感知
type polarPoint struct {
    r, theta float64
}
func (p *polarPoint) GetX() float64     { return p.r * math.Cos(p.theta) }
func (p *polarPoint) GetY() float64     { return p.r * math.Sin(p.theta) }
func (p *polarPoint) GetR() float64     { return p.r }
func (p *polarPoint) GetTheta() float64 { return p.theta }

// 数据：纯结构体
type Square struct {
    Side float64
}

type Rectangle struct {
    Height float64
    Width  float64
}

type Circle struct {
    Radius float64
}

// 函数：所有操作在外部
func Area(shape any) float64 {
    switch s := shape.(type) {
    case Square:
        return s.Side * s.Side
    case Rectangle:
        return s.Height * s.Width
    case Circle:
        return math.Pi * s.Radius * s.Radius
    }
    return 0
}

// 加新函数（如 Perimeter）→ 容易，加一个函数就行
// 加新类型（如 Triangle）→ 痛苦，要改 Area、Perimeter 等所有函数

// 接口：定义行为
type Shape interface {
    Area() float64
}

// 每个类型自己实现
type Square struct {
    Side float64
}
func (s Square) Area() float64 {
    return s.Side * s.Side
}

type Rectangle struct {
    Height float64
    Width  float64
}
func (r Rectangle) Area() float64 {
    return r.Height * r.Width
}

type Circle struct {
    Radius float64
}
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

// 加新类型（如 Triangle）→ 容易，实现 Area() 即可
// 加新函数（如 Perimeter）→ 痛苦，要给所有已有类型加 Perimeter() 方法

type Address struct {
    City string
}

type Department struct {
    Address Address
}

type Employee struct {
    Department Department
}

// 调用方
func GetCity(e Employee) string {
    return e.Department.Address.City  // 翻了三层，违规
}

// ---

func (e Employee) GetCity() string {
    return e.department.GetCity()  // Employee 自己负责
}

// 调用方只跟 Employee 打交道
func GetCity(e Employee) string {
    return e.GetCity()  // 只点了一次，合规
}

// 不好的做法：直接把 map 暴露给整个系统
type Sensors struct {
    Data map[string]Sensor  // 字段公开，到处都能直接修改
}

// 到处都在直接操作 map
sensors.Data["temp"] = NewSensor("temp")
sensor := sensors.Data["temp"]
delete(sensors.Data, "temp")

// 好的做法：封装，只暴露需要的方法
type Sensors struct {
    data map[string]Sensor  // 私有字段，外部不能直接访问
}

func NewSensors() *Sensors {
    return &Sensors{
        data: make(map[string]Sensor),
    }
}

func (s *Sensors) Add(sensor Sensor) {
    // 可以加验证、日志等
    s.data[sensor.ID()] = sensor
}

func (s *Sensors) Get(id string) (Sensor, bool) {
    val, ok := s.data[id]
    return val, ok
}

func (s *Sensors) Remove(id string) {
    delete(s.data, id)
}

// 调用方只能使用你暴露的方法，不会直接触碰底层 map

// 好的做法：拆分成多个单一职责的类/结构体

type Dashboard struct {
    widgets []Widget
}

func (d *Dashboard) GetLastFocusedWidget() *Widget { ... }

type VersionInfo struct {
    version string
}

func (v *VersionInfo) GetComponentVersion() string { ... }

type UserPreferences struct {
    data map[string]string
}

func (up *UserPreferences) Save() error { ... }

type LayoutEngine struct {
    cache Layout
}

func (le *LayoutEngine) Calculate() Layout { ... }

type ErrorReporter struct{}

func (er *ErrorReporter) Send(err error) { ... }

// 定义接口
type SqlGenerator interface {
    Generate() string
}

// Oracle 实现
type OracleSqlGenerator struct{}

func (g OracleSqlGenerator) Generate() string {
    return "SELECT * FROM table" // Oracle 特定语法
}

// SQL Server 实现
type SqlServerSqlGenerator struct{}

func (g SqlServerSqlGenerator) Generate() string {
    return "SELECT * FROM table" // SQL Server 特定语法
}

// 新增 PostgreSQL 支持：完全不改已有代码
type PostgreSqlGenerator struct{}

func (g PostgreSqlGenerator) Generate() string {
    return "SELECT * FROM table" // PostgreSQL 特定语法
}

// 依赖通过参数传递
func ExecuteQuery(generator SqlGenerator) error {
    sql := generator.Generate()
    // 执行 sql...
}

// 好的做法：对象已经建好了传进来，业务逻辑只负责用它

type OrderProcessor struct {
    db *sql.DB  // 依赖由外部注入，不自己创建
}

func NewOrderProcessor(db *sql.DB) *OrderProcessor {
    return &OrderProcessor{db: db}
}

func (p *OrderProcessor) ProcessOrder(order Order) error {
    // 业务逻辑只关心“使用”db，不关心“创建”db
    result, err := p.db.Exec("INSERT INTO orders ...", order.ID, order.Amount)
    // ...
}

// 在 main.go 或启动文件中“构造”
func main() {
    db, err := sql.Open("mysql", "user:pass@tcp(127.0.0.1:3306)/db")
    if err != nil {
        panic(err)
    }
    defer db.Close()
    
    processor := NewOrderProcessor(db)  // 注入
    processor.ProcessOrder(order)
}