// 完整声明
var name string = "OpenGIS"

// 类型推导
var version = 1.0

// 短变量声明（最常用，只能在函数内）
count := 42

// 批量声明
var (
    host     = "localhost"
    port     = 5432
    database = "gis"
)

// 常量：可以是无类型常量（高精度）
const Pi = 3.14159265358979323846
const (
    StatusOK    = 200
    StatusError = 500
)

// 标准 for 循环
for i := 0; i < 10; i++ {
    fmt.Println(i)
}

// 类似 while：只有条件
sum := 1
for sum < 1000 {
    sum += sum
}

// 无限循环（等价于 while true）
for {
    // 通过 break 退出
    if done {
        break
    }
}

// range 遍历：数组/切片/map/字符串/通道
nums := []int{2, 3, 5, 7}
for index, value := range nums {
    fmt.Printf("nums[%d] = %d\n", index, value)
}

// 忽略索引
for _, value := range nums {
    fmt.Println(value)
}

// if 支持在条件前执行简短语句（分号分隔）
if err := doSomething(); err != nil {
    return fmt.Errorf("failed: %w", err)
}

// switch 不需要 break（默认不 fall through）
switch os := runtime.GOOS; os {
case "darwin":
    fmt.Println("macOS")
case "linux":
    fmt.Println("Linux")
default:
    fmt.Printf("%s\n", os)
}

// 无表达式的 switch 等同于 if-else 链
t := time.Now()
switch {
case t.Hour() < 12:
    fmt.Println("Good morning")
case t.Hour() < 18:
    fmt.Println("Good afternoon")
default:
    fmt.Println("Good evening")
}

// 多返回值（Go 的标志性特性）
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a / b, nil
}

// 命名返回值（naked return）
func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return  // 返回 x 和 y
}

// 可变参数
func sum(nums ...int) int {
    total := 0
    for _, n := range nums {
        total += n
    }
    return total
}
// 调用：sum(1, 2, 3, 4)

// 闭包
func adder() func(int) int {
    sum := 0
    return func(x int) int {
        sum += x
        return sum
    }
}
// pos, neg := adder(), adder()
// pos(1) → 1, pos(2) → 3, neg(-1) → -1

type Point struct {
    X, Y float64
    CRS  string  // 坐标参考系
}

// 值接收者：只读，不修改原值
func (p Point) DistanceTo(q Point) float64 {
    dx := p.X - q.X
    dy := p.Y - q.Y
    return math.Sqrt(dx*dx + dy*dy)
}

// 指针接收者：可修改原值
func (p *Point) Transform(scale float64) {
    p.X *= scale
    p.Y *= scale
}

// 定义接口
type Geometry interface {
    Area() float64
    Perimeter() float64
}

type Circle struct {
    Radius float64
}

// Circle 实现了 Geometry 接口（隐式）
func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

func (c Circle) Perimeter() float64 {
    return 2 * math.Pi * c.Radius
}

// 使用接口
func PrintInfo(g Geometry) {
    fmt.Printf("Area: %.2f, Perimeter: %.2f\n", g.Area(), g.Perimeter())
}

// 类型断言
var g Geometry = Circle{Radius: 5}
if c, ok := g.(Circle); ok {
    fmt.Printf("It's a circle with radius %.1f\n", c.Radius)
}

// 类型 switch
switch v := g.(type) {
case Circle:
    fmt.Printf("Circle: r=%.1f\n", v.Radius)
case nil:
    fmt.Println("nil")
default:
    fmt.Printf("Unknown type: %T\n", v)
}

// 泛型函数
func Min[T constraints.Ordered](a, b T) T {
    if a < b {
        return a
    }
    return b
}

// 泛型类型
type Stack[T any] struct {
    items []T
}

func (s *Stack[T]) Push(item T) {
    s.items = append(s.items, item)
}

func (s *Stack[T]) Pop() (T, bool) {
    if len(s.items) == 0 {
        var zero T
        return zero, false
    }
    item := s.items[len(s.items)-1]
    s.items = s.items[:len(s.items)-1]
    return item, true
}

// 泛型约束：只接受可比较的类型
func Contains[T comparable](slice []T, item T) bool {
    for _, v := range slice {
        if v == item {
            return true
        }
    }
    return false
}

// 启动 goroutine：只需在函数调用前加 go 关键字
go doSomething()

// 实际例子：并发下载多个 URL
urls := []string{"url1", "url2", "url3"}

for _, url := range urls {
    go func(u string) {  // 注意：用参数传递避免闭包陷阱
        resp, err := http.Get(u)
        if err != nil {
            log.Printf("Failed to fetch %s: %v", u, err)
            return
        }
        defer resp.Body.Close()
        // 处理响应
    }(url)
}

// 创建 channel
ch := make(chan int)        // 无缓冲 channel（同步）
ch := make(chan int, 10)    // 有缓冲 channel（缓冲 10 个）

// 发送和接收
ch <- 42        // 发送
value := <-ch   // 接收
value, ok := <-ch  // 接收，ok=false 表示 channel 已关闭

// 无缓冲 vs 有缓冲
// 无缓冲：发送方阻塞直到有接收方（同步），类似"当面交付"
// 有缓冲：缓冲满之前不阻塞（异步），类似"信箱投递"

// 生产者-消费者模式
func producer(ch chan<- int) {  // 单向通道：只能发送
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)  // 生产者关闭 channel，通知消费者不再有数据
}

func consumer(ch <-chan int) {  // 单向通道：只能接收
    for v := range ch {  // range 会在 channel 关闭后自动退出
        fmt.Println(v)
    }
}

ch := make(chan int, 5)
go producer(ch)
consumer(ch)

func worker(done <-chan struct{}, tasks <-chan Task, results chan<- Result) {
    for {
        select {
        case <-done:
            // 收到退出信号，清理资源后返回
            fmt.Println("Worker shutting down")
            return
        case task, ok := <-tasks:
            if !ok {
                return  // tasks channel 已关闭
            }
            result := process(task)
            results <- result
        case <-time.After(5 * time.Second):
            // 超时处理
            fmt.Println("No task received for 5 seconds")
        }
    }
}

// 创建 Context
ctx := context.Background()                    // 根 Context
ctx, cancel := context.WithCancel(ctx)         // 可取消
ctx, cancel := context.WithTimeout(ctx, 5*time.Second)  // 超时
ctx, cancel := context.WithDeadline(ctx, time.Now().Add(5*time.Second))  // 截止时间

// 通过 Context 传播取消
func fetchData(ctx context.Context, url string) error {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    if err != nil {
        return err
    }
    resp, err := http.DefaultClient.Do(req)
    // 如果 ctx 被取消，请求会自动中止
    return err
}

// 典型用法：HTTP 服务中的超时控制
func handler(w http.ResponseWriter, r *http.Request) {
    ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
    defer cancel()

    result, err := fetchData(ctx, "https://api.example.com/data")
    if err != nil {
        if errors.Is(err, context.DeadlineExceeded) {
            http.Error(w, "Request timed out", http.StatusGatewayTimeout)
            return
        }
        http.Error(w, err.Error(), http.StatusInternalServerError)
        return
    }
    // ...
}

// WaitGroup 示例：并发处理多个任务，等待全部完成
func processAll(items []string) {
    var wg sync.WaitGroup
    errors := make(chan error, len(items))

    for _, item := range items {
        wg.Add(1)  // 计数器 +1
        go func(it string) {
            defer wg.Done()  // 完成后计数器 -1
            if err := process(it); err != nil {
                errors <- err
            }
        }(item)
    }

    wg.Wait()       // 阻塞直到计数器归零
    close(errors)
}

// 基础 HTTP 服务
func main() {
    // 路由注册
    http.HandleFunc("/api/hello", helloHandler)
    http.HandleFunc("/api/gis/point", gisPointHandler)

    log.Println("Server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func helloHandler(w http.ResponseWriter, r *http.Request) {
    if r.Method != http.MethodGet {
        http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
        return
    }
    w.Header().Set("Content-Type", "application/json")
    w.WriteHeader(http.StatusOK)
    json.NewEncoder(w).Encode(map[string]string{"message": "Hello GIS!"})
}

import "github.com/gin-gonic/gin"

func main() {
    r := gin.Default()

    // GET 路由 + 路径参数
    r.GET("/api/gis/layer/:name", func(c *gin.Context) {
        name := c.Param("name")
        c.JSON(200, gin.H{
            "layer": name,
            "type":  "vector",
        })
    })

    // POST 路由 + JSON 绑定
    r.POST("/api/gis/geometry", func(c *gin.Context) {
        var geo struct {
            Type        string    `json:"type" binding:"required"`
            Coordinates []float64 `json:"coordinates" binding:"required"`
        }
        if err := c.ShouldBindJSON(&geo); err != nil {
            c.JSON(400, gin.H{"error": err.Error()})
            return
        }
        c.JSON(200, gin.H{"received": geo})
    })

    // 路由分组 + 中间件
    api := r.Group("/api")
    api.Use(authMiddleware())
    {
        api.GET("/admin/users", listUsers)
        api.POST("/admin/users", createUser)
    }

    r.Run(":8080")
}

// geometry_test.go
package gis

import "testing"

// 单元测试
func TestCalculateDistance(t *testing.T) {
    p1 := Point{120.0, 30.0}
    p2 := Point{121.0, 31.0}

    dist := p1.DistanceTo(p2)

    // 基于已知值验证（上海到南京的粗略经度差约 1°）
    if dist < 90000 || dist > 120000 {
        t.Errorf("Expected distance ~100km, got %f meters", dist)
    }
}

// 表格驱动测试（Go 测试的惯用模式）
func TestProjection(t *testing.T) {
    tests := []struct {
        name     string
        inputEPSG int
        wantEPSG  int
        wantErr   bool
    }{
        {"WGS84 to Web Mercator", 4326, 3857, false},
        {"Web Mercator to WGS84", 3857, 4326, false},
        {"Invalid EPSG", 9999, 0, true},
    }

    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            result, err := Project(tt.inputEPSG, tt.wantEPSG)
            if tt.wantErr && err == nil {
                t.Error("Expected error but got none")
            }
            if !tt.wantErr && err != nil {
                t.Errorf("Unexpected error: %v", err)
            }
            _ = result // 在实际代码中验证结果
        })
    }
}

// 基准测试（函数名以 Benchmark 开头）
func BenchmarkCalculateDistance(b *testing.B) {
    p1 := Point{120.0, 30.0}
    p2 := Point{121.0, 31.0}

    b.ResetTimer()  // 重置计时器，排除初始化开销
    for i := 0; i < b.N; i++ {
        p1.DistanceTo(p2)
    }
}
// 运行：go test -bench=. -benchmem

package main

import (
    "github.com/go-vgo/robotgo"
)

func main() {
    // 获取当前鼠标位置
    x, y := robotgo.Location()
    fmt.Printf("Mouse at: (%d, %d)\n", x, y)

    // 移动鼠标到绝对位置
    robotgo.Move(500, 300)

    // 相对移动（从当前位置偏移 dx, dy）
    robotgo.MoveRelative(100, -50)

    // 鼠标点击
    robotgo.Click()           // 左键单击
    robotgo.Click("right")    // 右键单击
    robotgo.Click("center")   // 中键（滚轮）单击

    // 双击
    robotgo.Move(800, 600)
    robotgo.DoubleClick()

    // 拖拽：从 A 点拖到 B 点
    robotgo.Move(100, 200)
    robotgo.Toggle("down")    // 按下左键
    robotgo.MoveSmooth(500, 400)  // 平滑移动到目标位置
    robotgo.Toggle("up")      // 释放左键

    // 滚轮滚动（正数向上，负数向下）
    robotgo.Scroll(0, -3)  // 向下滚动 3 个单位
    robotgo.Scroll(10, 0)  // 水平向右滚动
}

// 单个按键
robotgo.KeyTap("enter")
robotgo.KeyTap("tab")
robotgo.KeyTap("escape")

// 组合键（Ctrl+C, Ctrl+V, Alt+F4 等）
robotgo.KeyTap("c", "ctrl")        // Ctrl+C
robotgo.KeyTap("v", "ctrl")        // Ctrl+V
robotgo.KeyTap("f4", "alt")        // Alt+F4
robotgo.KeyTap("delete", "ctrl", "alt")  // Ctrl+Alt+Delete

// 文本输入（模拟打字，支持中文）
robotgo.TypeStr("Hello 世界！")

// 带有延迟的打字（每个字符间隔若干毫秒，更接近真人输入）
robotgo.TypeStrDelay("Slow typing...", 100)  // 每字 100ms

// 全屏截图并保存为 PNG
bitmap := robotgo.CaptureScreen()
robotgo.Save(bitmap, "screenshot.png")
robotgo.FreeBitmap(bitmap)  // 释放内存

// 区域截图
// Capture(x, y, width, height)
bitmap := robotgo.Capture(100, 100, 400, 300)
robotgo.Save(bitmap, "region.png")
robotgo.FreeBitmap(bitmap)

// 获取屏幕尺寸
width, height := robotgo.GetScreenSize()
fmt.Printf("Screen: %d x %d\n", width, height)

// 获取像素颜色（常用于判断某个状态变化）
color := robotgo.GetPixelColor(500, 300)
fmt.Printf("Color at (500,300): %s\n", color)  // 十六进制 "#RRGGBB"

// 查找屏幕上与 template.png 匹配的位置
// 返回 (x, y) 为匹配区域的左上角坐标
x, y := robotgo.FindImg("button.png")
if x != -1 && y != -1 {
    fmt.Printf("Found at (%d, %d)\n", x, y)
    robotgo.Move(x+10, y+10)  // 移到匹配区域中心附近
    robotgo.Click()
} else {
    fmt.Println("Not found")
}

// 带精度阈值的查找
bitmap := robotgo.CaptureScreen()
fx, fy := robotgo.FindBitmap("icon.png", bitmap, 0.9)  // 0.9 = 90% 相似度
robotgo.FreeBitmap(bitmap)

// 查找所有匹配位置
points := robotgo.FindEveryImg("checkbox.png")
for _, p := range points {
    robotgo.Move(p.X, p.Y)
    robotgo.Click()
}

package main

import (
    "fmt"
    "github.com/go-vgo/robotgo"
)

func main() {
    // 添加全局键盘事件
    robotgo.EventHook(robotgo.KeyDown, func(event robotgo.Event) {
        fmt.Printf("Key pressed: Keycode=%d, Rawcode=%d\n", 
            event.Keycode, event.Rawcode)

        // 按 ESC 退出
        if event.Keycode == robotgo.VK_ESC {
            robotgo.EventEnd()  // 停止事件监听
        }
    })

    // 添加全局鼠标事件
    robotgo.EventHook(robotgo.MouseMove, func(event robotgo.Event) {
        // 注意：鼠标移动事件非常频繁，不要在这里做耗时操作
    })

    robotgo.EventHook(robotgo.MouseDown, func(event robotgo.Event) {
        fmt.Printf("Mouse button %d down at (%d, %d)\n", 
            event.Button, event.X, event.Y)
    })

    fmt.Println("Listening for events... Press ESC to exit")
    robotgo.EventStart()  // 阻塞，开始事件循环
    fmt.Println("Event loop ended")
}

// 常用虚拟键码（VK_*）
// robotgo.VK_ESC    - Escape
// robotgo.VK_SPACE  - 空格
// robotgo.VK_RETURN - 回车
// robotgo.VK_TAB    - Tab
// robotgo.VK_BACK   - 退格
// robotgo.VK_SHIFT  - Shift
// robotgo.VK_CTRL   - Ctrl
// robotgo.VK_ALT    - Alt

// 获取当前活动窗口的标题和句柄
title := robotgo.GetTitle()
fmt.Printf("Active window: %s\n", title)

// 获取所有窗口标题
titles := robotgo.GetAllTitles()
for _, t := range titles {
    fmt.Println(t)
}

// 按标题查找窗口并激活
hwnd := robotgo.FindWindow("记事本")
if hwnd != 0 {
    robotgo.ActiveWindow(hwnd)  // 激活窗口（置前）
    robotgo.MaxWindow(hwnd)     // 最大化
}

// 获取窗口位置和大小
x, y, w, h := robotgo.GetBounds(hwnd)
fmt.Printf("Window: pos=(%d,%d), size=(%d,%d)\n", x, y, w, h)

// 移动和调整窗口
robotgo.SetBounds(hwnd, 0, 0, 800, 600)

package main

import (
    "fmt"
    "os/exec"
    "time"
    "github.com/go-vgo/robotgo"
)

func main() {
    // Windows 打开计算器
    exec.Command("calc.exe").Start()
    time.Sleep(2 * time.Second)  // 等待启动

    // 找到计算器窗口并激活
    hwnd := robotgo.FindWindow("计算器")
    robotgo.ActiveWindow(hwnd)
    robotgo.MaxWindow(hwnd)
    time.Sleep(500 * time.Millisecond)

    // 执行 1 + 1 =
    robotgo.TypeStr("1")
    time.Sleep(200 * time.Millisecond)
    robotgo.TypeStr("+")
    time.Sleep(200 * time.Millisecond)
    robotgo.TypeStr("1")
    time.Sleep(200 * time.Millisecond)
    robotgo.KeyTap("enter")  // =
    time.Sleep(200 * time.Millisecond)

    // 截图保存结果
    bitmap := robotgo.CaptureScreen()
    robotgo.Save(bitmap, "calc_result.png")
    fmt.Println("Screenshot saved to calc_result.png")
    robotgo.FreeBitmap(bitmap)
}