func RenderItem(name string, disabled bool) {
    installedPen := color.New(color.FgHiGreen).PrintFunc()
    notInstalledPen := color.New(color.FgRed).PrintFunc()
    softwareNamePen := color.New(color.FgWhite).PrintFunc()

    softwareNamePen(name)
    if disabled {
        installedPen(" - Installed")
    } else {
        notInstalledPen(" - Not Installed")
    }
}

type SelectItem struct {
    Name        string
    Render      func(name string, disabled bool)
    Run         func()
    GetDisabled func() bool
    Disabled    bool
}

func (si *SelectItem) UpdateDisabled() {
    if si.GetDisabled != nil {
        si.Disabled = si.GetDisabled()
    }
}

func ShowCursor() {
    fmt.Print("\033[?25h")
}

func HideCursor() {
    fmt.Print("\033[?25l")
}

func ClearConsole() {
    cmd := exec.Command("clear")
    cmd.Stdout = os.Stdout
    cmd.Run()
}

func MoveCursor(x, relativeY int) {
    if relativeY < 0 {
        fmt.Printf("\033[%dA\033[%dG", -relativeY, x)
    } else {
        fmt.Printf("\033[%dB\033[%dG", relativeY, x)
    }
}

/*
Display items and returns the name of the item
If user presses esc, it returns empty string with an error
*/
func Select(items []SelectItem) (string, error) {
    print := color.New(color.FgWhite).PrintfFunc()
    cursor := color.New(color.FgGreen).Add(color.Bold).PrintFunc()
    itemLength := len(items)
    currentIndex := 0

    for _, item := range items {
        print("   ")

        if item.Render != nil {
            item.Render(item.Name, item.Disabled)
        } else {
            print(item.Name)
        }

        print("\n")
    }

    eraseCurrentCursor := func() {
        MoveCursor(1, -itemLength+currentIndex)
        cursor(" ")
        MoveCursor(1, -(-itemLength + currentIndex))
    }

    drawCurrentCursor := func() {
        MoveCursor(1, -itemLength+currentIndex)
        cursor(">")
        MoveCursor(1, -(-itemLength + currentIndex))
    }

    drawCurrentCursor()

    t, err := tty.Open()
    if err != nil {
        panic(err)
    }
    defer t.Close()

    for {
        r, _ := t.ReadRune()

        switch r {
        case '\x1b':
            return "", errors.New("Escape")
        case 'j', 'J', 'h', 'H':
            if currentIndex >= itemLength-1 {
                break
            }
            eraseCurrentCursor()
            currentIndex++
            drawCurrentCursor()
        case 'k', 'K', 'l', 'L':
            if currentIndex <= 0 {
                break
            }
            eraseCurrentCursor()
            currentIndex--
            drawCurrentCursor()
        }

        if (r == '\r' || r == '\n') && !items[currentIndex].Disabled {
            break
        }
    }

    return items[currentIndex].Name, nil
}

func ExistBrewPackage(packageName string) bool {
    _, err := exec.Command("brew", "list", packageName).Output()

    if err != nil {
        return false
    }

    return true
}

func ExistApplication(appName string) bool {
    ls := exec.Command("ls", "/Applications")
    grep := exec.Command("grep", appName)

    pipe, err := ls.StdoutPipe()
    defer pipe.Close()

    if err != nil {
        panic(err)
    }

    grep.Stdin = pipe

    err = ls.Start()

    if err != nil {
        panic(err)
    }

    output, err := grep.Output()

    if err != nil {
        return false
    }

    return len(string(output)) >= len(appName)
}

func ExecCommand(command string, args ...string) {
    cmd := exec.Command(command, args...)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stdout

    if err := cmd.Start(); err != nil {
        panic(err)
    }

    if err := cmd.Wait(); err != nil {
        panic(err)
    }
}

// ...
    case "Git":
        return ExistBrewPackage("git"), nil
    case "WezTerm":
        return ExistApplication("WezTerm.app"), nil
    case "Neovim":
        return ExistCommand("nvim"), nil
// ...

// ...
    case "fzf":
        ExecCommand("brew", "install", "fzf")
    case "zsh-vi-mode":
        ExecCommand("brew", "install", "zsh-vi-mode")
        AddZshSource("source $(brew --prefix)/opt/zsh-vi-mode/share/zsh-vi-mode/zsh-vi-mode.plugin.zsh")
        WarningMessage("Run source ~/.zshrc to use zsh-vi-mode without reopening the terminal.")
    case "docker":
        ExecCommand("brew", "install", "docker")
    case "ruby":
        ExecCommand("brew", "install", "ruby")
// ...

// ...
    ExecCommand("mkdir", "-p", devSetupManagerHomePath)

    if exist, _ := existFile(devSetupManagerDotfilesPath); exist {
        ExecCommand("rm", "-rf", devSetupManagerDotfilesPath)
    }

    ExecCommand("git", "clone", "git@github.com:hsk-kr/dotfiles.git", devSetupManagerDotfilesPath)

    ExecCommand("mkdir", "-p", configDirPath)

    copyItems := []string{
        "aerospace",
        "devdeck",
        "karabiner",
        "nvim",
        "tmux",
        "zsh",
    }

    for _, copyItem := range copyItems {
        ExecCommand("ln", "-sfn", fmt.Sprintf("%s/%s", devSetupManagerDotfilesPath, copyItem), fmt.Sprintf("%s/%s", configDirPath, copyItem))
    }

    ExecCommand("ln", "-sfn", fmt.Sprintf("%s/%s", devSetupManagerDotfilesPath, "scripts"), fmt.Sprintf("%s/%s", homePath, "scripts"))

    AddZshSource(fmt.Sprintf("source %s/%s", configDirPath, "zsh/zshrc"))
// ...

name: Build and Release

on:
  workflow_dispatch:
    inputs:
      version:
        description: "Version number"
        required: true
        default: "v0.1.0"

jobs:
  build-and-release:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v4
        with:
          ref: main

      - name: Setup Go
        uses: actions/setup-go@v5
        with:
          go-version: '1.24'

      - name: Build for macOS (M1)
        run: GOOS=darwin GOARCH=arm64 go build -o dev-setup-manager main.go

      - name: Upload binaries as artifacts
        uses: actions/upload-artifact@v4
        with:
          name: binaries
          path: |
            dev-setup-manager

      - name: Create a Release
        uses: ncipollo/release-action@v1
        with:
          artifacts: "dev-setup-manager"
          tag: ${{ inputs.version }}