# 安装编译工具链
apk add gcc g++ make cmake musl-dev

# 安装调试工具
apk add gdb strace ltrace valgrind

# 安装常用库
apk add openssl-dev zlib-dev libffi-dev linux-headers

# 编译示例
cat > hello.c << 'EOF'
#include <stdio.h>
int main() {
    printf("Hello from Alpine!\n");
    return 0;
}
EOF

# 动态链接编译
gcc -o hello_dynamic hello.c

# 静态链接编译（Alpine 特色，可独立运行）
gcc -static -o hello_static hello.c

# 查看依赖
ldd hello_dynamic   # 显示动态库依赖
ldd hello_static    # 显示 "not a dynamic executable"

# Makefile 示例
cat > Makefile << 'EOF'
CC = gcc
CFLAGS = -Wall -Wextra -O2
LDFLAGS = -lm

TARGET = myapp
SRCS = main.c utils.c
OBJS = $(SRCS:.c=.o)

all: $(TARGET)

$(TARGET): $(OBJS)
	$(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

clean:
	rm -f $(OBJS) $(TARGET)

.PHONY: all clean
EOF

# 安装 Python
apk add python3 py3-pip py3-virtualenv py3-wheel

# 创建虚拟环境
python3 -m venv ~/venvs/myproject
source ~/venvs/myproject/bin/activate

# 安装常用包
pip install --upgrade pip
pip install requests flask sqlalchemy

# 常用 Python 开发包
apk add py3-numpy py3-scipy  # 数值计算（社区仓库）
py3-pillow                   # 图像处理
py3-cryptography             # 加密

# 虚拟环境最佳实践
cat > /usr/local/bin/mkvenv << 'SCRIPT'
#!/bin/sh
# 创建并激活虚拟环境
VENV_DIR="${1:-.venv}"
python3 -m venv "$VENV_DIR"
echo "Virtual environment created at $VENV_DIR"
echo "Activate with: source $VENV_DIR/bin/activate"
SCRIPT
chmod +x /usr/local/bin/mkvenv

# 项目结构
mkdir -p ~/projects/flask-app
cd ~/projects/flask-app

cat > requirements.txt << 'EOF'
flask>=3.0
gunicorn>=21.0
python-dotenv>=1.0
EOF

cat > app.py << 'EOF'
from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/')
def index():
    return jsonify({"message": "Hello from Alpine!", "status": "ok"})

@app.route('/health')
def health():
    return jsonify({"status": "healthy"})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)
EOF

cat > Dockerfile << 'EOF'
FROM python:3.12-alpine AS builder
WORKDIR /app
RUN apk add --no-cache gcc musl-dev
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

FROM python:3.12-alpine
WORKDIR /app
COPY --from=builder /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
COPY . .
EXPOSE 5000
CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "app:app"]
EOF

# 安装 Node.js
apk add nodejs npm

# 安装 Yarn
npm install -g yarn

# 安装 pnpm（推荐）
npm install -g pnpm

# Node.js 版本管理（使用 n）
npm install -g n
n lts         # 安装 LTS 版本
n latest      # 安装最新版

# 或使用 nvm
apk add nvm
source /usr/share/nvm/nvm.sh
nvm install --lts
nvm use --lts

# 初始化项目
mkdir ~/projects/node-app && cd ~/projects/node-app
npm init -y

# 安装依赖
npm install express cors helmet

# 开发依赖
npm install -D nodemon eslint prettier

cat > src/index.js << 'EOF'
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');

const app = express();
app.use(cors());
app.use(helmet());
app.use(express.json());

app.get('/', (req, res) => {
    res.json({ message: 'Hello from Alpine!', status: 'ok' });
});

app.get('/health', (req, res) => {
    res.json({ status: 'healthy', uptime: process.uptime() });
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});
EOF

# package.json scripts
cat > package.json << 'EOF'
{
    "name": "node-app",
    "version": "1.0.0",
    "scripts": {
        "start": "node src/index.js",
        "dev": "nodemon src/index.js",
        "lint": "eslint src/"
    }
}
EOF

# 安装 Go
apk add go

# 设置环境变量
cat >> ~/.bashrc << 'EOF'
export GOPATH=$HOME/go
export PATH=$PATH:/usr/local/go/bin:$GOPATH/bin
EOF
source ~/.bashrc

# 验证安装
go version
go env

# 初始化项目
mkdir ~/projects/go-app && cd ~/projects/go-app
go mod init github.com/user/go-app

cat > main.go << 'EOF'
package main

import (
    "encoding/json"
    "log"
    "net/http"
    "os"
    "time"
)

type Response struct {
    Message   string `json:"message"`
    Status    string `json:"status"`
    Timestamp string `json:"timestamp"`
}

func main() {
    http.HandleFunc("/", handleRoot)
    http.HandleFunc("/health", handleHealth)

    port := os.Getenv("PORT")
    if port == "" {
        port = "8080"
    }

    log.Printf("Server starting on port %s", port)
    if err := http.ListenAndServe(":"+port, nil); err != nil {
        log.Fatal(err)
    }
}

func handleRoot(w http.ResponseWriter, r *http.Request) {
    resp := Response{
        Message:   "Hello from Alpine!",
        Status:    "ok",
        Timestamp: time.Now().Format(time.RFC3339),
    }
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(resp)
}

func handleHealth(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "application/json")
    json.NewEncoder(w).Encode(map[string]string{"status": "healthy"})
}
EOF

# 构建静态二进制
CGO_ENABLED=0 go build -ldflags="-s -w" -o go-app .

# 运行
./go-app

# 多阶段 Docker 构建
cat > Dockerfile << 'EOF'
FROM golang:1.22-alpine AS builder
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /go-app .

FROM scratch
COPY --from=builder /go-app /go-app
EXPOSE 8080
ENTRYPOINT ["/go-app"]
EOF

# 安装 Rust
apk add rust cargo

# 或使用 rustup（推荐）
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source $HOME/.cargo/env

# 创建项目
cargo new my-rust-app
cd my-rust-app

# 构建
cargo build          # 调试构建
cargo build --release # 发布构建

# 运行
cargo run

# 添加 musl 目标
rustup target add x86_64-unknown-linux-musl
rustup target add aarch64-unknown-linux-musl

# 静态编译
cargo build --release --target x86_64-unknown-linux-musl

# 交叉编译 ARM64
apk add cross-gcc-aarch64-linux-musl
CC=aarch64-linux-musl-gcc \
cargo build --release --target aarch64-unknown-linux-musl

# 安装 JDK
apk add openjdk21

# 或使用 Temurin
apk add temurin21-jdk

# 验证
java -version
javac -version

# Maven
apk add maven

# Gradle
apk add gradle

# 设置 JAVA_HOME
export JAVA_HOME=/usr/lib/jvm/java-21-openjdk

# 安装 PHP
apk add php83 php83-fpm php83-cli php83-json php83-mbstring \
    php83-openssl php83-pdo php83-pdo_mysql php83-pgsql \
    php83-curl php83-xml php83-zip php83-gd php83-intl

# Composer
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php --install-dir=/usr/local/bin --filename=composer

# 配置 PHP-FPM
vi /etc/php83/php-fpm.d/www.conf

# 启动
rc-update add php-fpm83
rc-service php-fpm83 start

# SQLite
apk add sqlite

# MariaDB
apk add mariadb mariadb-client

# PostgreSQL
apk add postgresql16 postgresql16-client

# Redis
apk add redis

# MongoDB（社区仓库）
apk add mongodb

# 创建开发数据库
# PostgreSQL
su - postgres -c "createuser -s devuser"
su - postgres -c "createdb -O devuser devdb"

# Git
apk add git git-lfs

# Docker（用于容器化开发）
apk add docker docker-compose

# API 测试
apk add httpie        # http 命令
npm install -g newman # Postman CLI

# 代码编辑器
apk add vim neovim

# 终端工具
apk add tmux htop tree jq fzf ripgrep fd

# 文档生成
apk add doxygen

# 在 Alpine 安装 VS Code Server 依赖
apk add gcompat libstdc++ libgcc

# VS Code Remote SSH 配置
# ~/.ssh/config
Host alpine-dev
    HostName 192.168.1.100
    User myuser
    IdentityFile ~/.ssh/id_ed25519