#!/bin/bash
# Module Development Environment Setup
# 设置KernelSU模块开发环境

set -euo pipefail

VERSION="1.0.0"
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
USR_DIR="$(dirname "$(dirname "$SCRIPT_DIR")")"

# 颜色输出
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m'

show_help() {
    cat << EOF
Module Development Environment Setup v${VERSION}

Usage: $(basename "$0") [options]

Options:
    -h, --help          显示此帮助信息
    -w, --workspace DIR 设置工作空间目录 (默认: ~/kernelsu-dev)
    -c, --config        仅生成配置文件
    -v, --verbose       详细输出

Description:
    此工具会设置一个完整的KernelSU模块开发环境，包括：
    - 创建项目工作空间
    - 生成开发配置文件
    - 设置IDE集成
    - 安装开发依赖
EOF
}

log() {
    echo -e "${GREEN}[INFO]${NC} $*"
}

warn() {
    echo -e "${YELLOW}[WARN]${NC} $*"
}

error() {
    echo -e "${RED}[ERROR]${NC} $*"
    exit 1
}

debug() {
    if [[ "${VERBOSE:-}" == "true" ]]; then
        echo -e "${BLUE}[DEBUG]${NC} $*"
    fi
}

create_workspace() {
    local workspace="$1"
    
    log "Creating workspace: $workspace"
    mkdir -p "$workspace"
    
    # 创建项目结构
    mkdir -p "$workspace"/{projects,templates,tools,configs}
    
    # 复制模板
    if [[ -d "${USR_DIR}/share/templates" ]]; then
        cp -r "${USR_DIR}/share/templates"/* "$workspace/templates/"
        debug "Templates copied to workspace"
    fi
    
    # 创建项目示例
    create_sample_project "$workspace/projects/sample-module"
}

create_sample_project() {
    local project_dir="$1"
    
    log "Creating sample project: $project_dir"
    mkdir -p "$project_dir"
    
    # 基本模块文件
    cat > "$project_dir/module.prop" << 'EOF'
id=sample_module
name=Sample KernelSU Module
version=v1.0.0
versionCode=1
author=KernelSU Developer
description=A sample KernelSU module for demonstration
EOF
    
    cat > "$project_dir/post-fs-data.sh" << 'EOF'
#!/system/bin/sh
# This script will be executed in post-fs-data mode

# 模块日志函数
log_print() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> /data/local/tmp/sample_module.log
}

log_print "Sample module post-fs-data script started"

# 在这里添加你的post-fs-data逻辑
# 这个阶段可以访问/data分区，但系统服务可能还未完全启动

log_print "Sample module post-fs-data script completed"
EOF
    
    cat > "$project_dir/service.sh" << 'EOF'
#!/system/bin/sh
# This script will be executed in late_start service mode

# 模块日志函数
log_print() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> /data/local/tmp/sample_module.log
}

log_print "Sample module service script started"

# 在这里添加你的服务逻辑
# 这个阶段系统已经完全启动，所有服务都可用

log_print "Sample module service script completed"
EOF
    
    cat > "$project_dir/README.md" << 'EOF'
# Sample KernelSU Module

这是一个示例KernelSU模块，演示了基本的模块结构和功能。

## 功能

- 基本的post-fs-data和service脚本
- 日志记录
- 模块属性配置

## 安装

1. 使用module-builder构建模块
2. 安装到KernelSU

## 开发

修改相应的脚本文件来实现你的功能。

### 文件说明

- `module.prop`: 模块属性文件
- `post-fs-data.sh`: 早期启动脚本
- `service.sh`: 服务脚本
- `README.md`: 说明文档

## 调试

查看日志文件：
```bash
adb shell cat /data/local/tmp/sample_module.log
```
EOF
    
    chmod +x "$project_dir/post-fs-data.sh"
    chmod +x "$project_dir/service.sh"
}

create_vscode_config() {
    local workspace="$1"
    
    log "Creating VS Code configuration"
    mkdir -p "$workspace/.vscode"
    
    # 工作空间设置
    cat > "$workspace/.vscode/settings.json" << 'EOF'
{
    "files.associations": {
        "*.prop": "properties",
        "*.rule": "plaintext"
    },
    "terminal.integrated.cwd": "${workspaceFolder}",
    "shellcheck.enable": true,
    "shellcheck.executablePath": "shellcheck",
    "files.eol": "\n",
    "files.insertFinalNewline": true,
    "files.trimTrailingWhitespace": true,
    "editor.detectIndentation": false,
    "editor.insertSpaces": true,
    "editor.tabSize": 4,
    "[shellscript]": {
        "editor.tabSize": 4,
        "editor.insertSpaces": true
    }
}
EOF
    
    # 任务配置
    cat > "$workspace/.vscode/tasks.json" << 'EOF'
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Build Module",
            "type": "shell",
            "command": "module-builder",
            "args": ["${workspaceFolder}/projects/${input:projectName}"],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": false,
                "panel": "shared"
            },
            "problemMatcher": []
        },
        {
            "label": "Validate Module",
            "type": "shell",
            "command": "module-validator",
            "args": ["${workspaceFolder}/projects/${input:projectName}"],
            "group": "test",
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": false,
                "panel": "shared"
            }
        },
        {
            "label": "Package Module",
            "type": "shell",
            "command": "module-packager",
            "args": ["${workspaceFolder}/projects/${input:projectName}"],
            "group": "build",
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": false,
                "panel": "shared"
            }
        },
        {
            "label": "Deploy Module",
            "type": "shell",
            "command": "deploy-module",
            "args": ["${workspaceFolder}/projects/${input:projectName}/${input:projectName}.zip"],
            "group": "build",
            "presentation": {
                "echo": true,
                "reveal": "always",
                "focus": false,
                "panel": "shared"
            }
        }
    ],
    "inputs": [
        {
            "id": "projectName",
            "description": "Project name",
            "default": "sample-module",
            "type": "promptString"
        }
    ]
}
EOF
    
    # 调试配置（对于shell脚本）
    cat > "$workspace/.vscode/launch.json" << 'EOF'
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "Debug Shell Script",
            "type": "bashdb",
            "request": "launch",
            "program": "${file}",
            "cwd": "${workspaceFolder}",
            "internalConsoleOptions": "openOnSessionStart"
        }
    ]
}
EOF
    
    # 推荐的扩展
    cat > "$workspace/.vscode/extensions.json" << 'EOF'
{
    "recommendations": [
        "timonwong.shellcheck",
        "foxundermoon.shell-format",
        "rogalmic.bash-debug",
        "ms-vscode.vscode-json",
        "redhat.vscode-yaml",
        "ms-vscode.makefile-tools"
    ]
}
EOF
}

create_dev_scripts() {
    local workspace="$1"
    
    log "Creating development scripts"
    mkdir -p "$workspace/tools"
    
    # 快速新建项目脚本
    cat > "$workspace/tools/new-project.sh" << 'EOF'
#!/bin/bash
# Quick project creation script

set -euo pipefail

if [[ $# -ne 1 ]]; then
    echo "Usage: $0 <project-name>"
    exit 1
fi

PROJECT_NAME="$1"
PROJECT_DIR="$(dirname "$0")/../projects/$PROJECT_NAME"

if [[ -d "$PROJECT_DIR" ]]; then
    echo "Project $PROJECT_NAME already exists"
    exit 1
fi

echo "Creating project: $PROJECT_NAME"
cp -r ../templates/* "$PROJECT_DIR/"

# 更新module.prop
sed -i "s/id=.*/id=$PROJECT_NAME/" "$PROJECT_DIR/module.prop"
sed -i "s/name=.*/name=$PROJECT_NAME/" "$PROJECT_DIR/module.prop"

echo "Project created: $PROJECT_DIR"
echo "You can now edit the files and build the module"
EOF
    
    # 清理脚本
    cat > "$workspace/tools/clean.sh" << 'EOF'
#!/bin/bash
# Clean build artifacts

set -euo pipefail

WORKSPACE_DIR="$(dirname "$0")/.."

echo "Cleaning build artifacts..."

find "$WORKSPACE_DIR/projects" -name "*.zip" -delete
find "$WORKSPACE_DIR/projects" -name "*.log" -delete
find "$WORKSPACE_DIR/projects" -name ".build" -type d -exec rm -rf {} + 2>/dev/null || true

echo "Cleanup completed"
EOF
    
    chmod +x "$workspace/tools"/*.sh
}

create_makefile() {
    local workspace="$1"
    
    log "Creating Makefile"
    cat > "$workspace/Makefile" << 'EOF'
# KernelSU Module Development Makefile

.PHONY: help build validate package clean deploy list

# Default project
PROJECT ?= sample-module

help:
	@echo "KernelSU Module Development Makefile"
	@echo ""
	@echo "Usage: make [target] [PROJECT=project-name]"
	@echo ""
	@echo "Targets:"
	@echo "  build      - Build the specified project"
	@echo "  validate   - Validate the specified project"
	@echo "  package    - Package the specified project"
	@echo "  deploy     - Deploy the specified project to device"
	@echo "  clean      - Clean build artifacts"
	@echo "  list       - List available projects"
	@echo ""
	@echo "Examples:"
	@echo "  make build PROJECT=my-module"
	@echo "  make deploy"

build:
	@echo "Building project: $(PROJECT)"
	module-builder projects/$(PROJECT)

validate:
	@echo "Validating project: $(PROJECT)"
	module-validator projects/$(PROJECT)

package:
	@echo "Packaging project: $(PROJECT)"
	module-packager projects/$(PROJECT)

deploy: package
	@echo "Deploying project: $(PROJECT)"
	deploy-module projects/$(PROJECT)/$(PROJECT).zip

clean:
	@echo "Cleaning build artifacts..."
	./tools/clean.sh

list:
	@echo "Available projects:"
	@ls -1 projects/ | grep -v "^\." || echo "No projects found"

new:
	@if [ -z "$(NAME)" ]; then \
		echo "Usage: make new NAME=project-name"; \
		exit 1; \
	fi
	@echo "Creating new project: $(NAME)"
	./tools/new-project.sh $(NAME)
EOF
}

create_gitignore() {
    local workspace="$1"
    
    log "Creating .gitignore"
    cat > "$workspace/.gitignore" << 'EOF'
# Build artifacts
*.zip
*.log
.build/
build/
dist/

# Temporary files
*.tmp
*.bak
*~

# IDE files
.vscode/settings.json
.idea/
*.swp
*.swo

# OS files
.DS_Store
Thumbs.db

# Local configuration
local.conf
EOF
}

setup_git() {
    local workspace="$1"
    
    if command -v git &> /dev/null; then
        log "Initializing git repository"
        cd "$workspace"
        
        if [[ ! -d ".git" ]]; then
            git init
            git add .
            git commit -m "Initial commit: KernelSU module development workspace"
        fi
        
        cd - > /dev/null
    else
        warn "Git not found, skipping repository initialization"
    fi
}

check_dependencies() {
    local missing_deps=()
    
    # 检查必需的工具
    if ! command -v shellcheck &> /dev/null; then
        missing_deps+=("shellcheck")
    fi
    
    if ! command -v zip &> /dev/null; then
        missing_deps+=("zip")
    fi
    
    if ! command -v unzip &> /dev/null; then
        missing_deps+=("unzip")
    fi
    
    if [[ ${#missing_deps[@]} -gt 0 ]]; then
        warn "Missing dependencies: ${missing_deps[*]}"
        warn "Please install them for full functionality"
    fi
}

main() {
    local workspace="$HOME/kernelsu-dev"
    local config_only=false
    
    # 解析命令行参数
    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                show_help
                exit 0
                ;;
            -w|--workspace)
                workspace="$2"
                shift 2
                ;;
            -c|--config)
                config_only=true
                shift
                ;;
            -v|--verbose)
                VERBOSE="true"
                shift
                ;;
            -*)
                error "Unknown option: $1"
                ;;
            *)
                error "Unexpected argument: $1"
                ;;
        esac
    done
    
    # 转换为绝对路径
    workspace="$(realpath "$workspace")"
    
    log "Setting up development environment at: $workspace"
    
    if [[ "$config_only" == "true" ]]; then
        log "Creating configuration files only"
        create_vscode_config "$workspace"
        create_gitignore "$workspace"
        create_makefile "$workspace"
        log "Configuration files created"
        return
    fi
    
    check_dependencies
    create_workspace "$workspace"
    create_vscode_config "$workspace"
    create_dev_scripts "$workspace"
    create_makefile "$workspace"
    create_gitignore "$workspace"
    setup_git "$workspace"
    
    log "Development environment setup completed!"
    log "Workspace: $workspace"
    log ""
    log "Next steps:"
    log "1. cd $workspace"
    log "2. Open in VS Code: code ."
    log "3. Create a new project: make new NAME=my-module"
    log "4. Build and test your module"
}

main "$@"
