package main

import (
        "fmt"
        "os"
)

func printBanner() {
        banner := `
   ____           ____ _     ___   ____                        _
  / ___| ___     / ___| |   |_ _| / ___|  __ _ _ __ ___  _ __ | | ___
 | |  _ / _ \   | |   | |    | |  \___ \ / _' | '_ ' _ \| '_ \| |/ _ \
 | |_| | (_) |  | |___| |___ | |   ___) | (_| | | | | | | |_) | |  __/
  \____|\___/    \____|_____|___| |____/ \__,_|_| |_| |_| .__/|_|\___|
                                                         |_|
                        ✨ シンプルでイケてるCLIツール ✨
        `
        fmt.Println(banner)
}

func main() {
        printBanner()
        fmt.Println("\nHello, ギャルエンジニア from Go CLI! ✨")
        if len(os.Args) > 1 {
                fmt.Printf("引数うけとったよ〜: %s\n", os.Args[1])
        }
}

package main

import (
        "flag"
        "fmt"
)

func main() {
        // フラグの定義だよ〜！🚩
        name := flag.String("name", "ギャルエンジニア", "あなたの名前を指定してね💕")
        count := flag.Int("count", 1, "何回繰り返すか指定だよ🔢")
        verbose := flag.Bool("verbose", false, "詳細表示モード👀")
        emoji := flag.String("emoji", "✨", "使う絵文字を指定してね🎨")

        // フラグをパース（これ大事🔥）
        flag.Parse()

        // verbose モードの場合は設定値を表示
        if *verbose {
                fmt.Println("=== 設定内容 ===")
                fmt.Printf("名前: %s\n", *name)
                fmt.Printf("繰り返し回数: %d\n", *count)
                fmt.Printf("絵文字: %s\n", *emoji)
                fmt.Println("================")
                fmt.Println()
        }

        // メイン処理✨
        for i := 0; i < *count; i++ {
                fmt.Printf("Hello, %s! %s\n", *name, *emoji)
        }

        // 追加の引数がある場合は表示
        if len(flag.Args()) > 0 {
                fmt.Printf("\nフラグ以外の引数: %v\n", flag.Args())
        }
}

package main

import (
        "bufio"
        "fmt"
        "os"
        "strings"
)

func main() {
        scanner := bufio.NewScanner(os.Stdin)

        fmt.Println("🎀 インタラクティブ CLI ツール ✨")
        fmt.Println("=====================================")
        fmt.Println()

        // 名前を入力してもらう 📝
        fmt.Print("あなたの名前を教えて〜: ")
        scanner.Scan()
        name := scanner.Text()
        if name == "" {
                name = "ギャルエンジニア"
        }

        // 好きな言語を入力してもらう 💻
        fmt.Print("好きなプログラミング言語は？: ")
        scanner.Scan()
        language := scanner.Text()
        if language == "" {
                language = "Go"
        }

        // 経験年数を入力してもらう 📊
        fmt.Print("何年くらい経験ある？（数字で入力してね）: ")
        scanner.Scan()
        experience := scanner.Text()
        if experience == "" {
                experience = "1"
        }

        fmt.Println()
        fmt.Println("=====================================")
        fmt.Println("📋 入力内容の確認")
        fmt.Println("=====================================")
        fmt.Printf("名前: %s\n", name)
        fmt.Printf("好きな言語: %s\n", language)
        fmt.Printf("経験年数: %s 年\n", experience)
        fmt.Println()

        // 確認をとる ✅
        fmt.Print("この内容で OK？ (yes/no): ")
        scanner.Scan()
        confirmation := strings.ToLower(strings.TrimSpace(scanner.Text()))

        if confirmation == "yes" || confirmation == "y" {
                fmt.Println()
                fmt.Printf("よっしゃ〜！%s さん、%s 歴 %s 年なんだね！✨\n", name, language, experience)
                fmt.Println("一緒にいいもの作っていこ〜！💪🔥")
        } else {
                fmt.Println()
                fmt.Println("またやり直してね〜！👋")
        }

        // エラーチェック
        if err := scanner.Err(); err != nil {
                fmt.Fprintf(os.Stderr, "エラーが発生したよ😢: %v\n", err)
                os.Exit(1)
        }
}

package main

import (
        "fmt"
        "os"
)

func main() {
        fmt.Println("📁 ファイル操作サンプル ✨")
        fmt.Println("========================================")
        fmt.Println()

        filename := "sample.txt"
        content := "Hello, ギャルエンジニア！✨\nGo でファイル操作できるよ〜🔥\n"

        // 1. ファイルの作成と書き込み 📝
        fmt.Println("1️⃣ ファイルを作成して書き込むよ〜")
        err := os.WriteFile(filename, []byte(content), 0644)
        if err != nil {
                fmt.Printf("❌ エラー: %v\n", err)
                os.Exit(1)
        }
        fmt.Printf("✅ %s を作成したよ！\n\n", filename)

        // 2. ファイルの存在確認 🔍
        fmt.Println("2️⃣ ファイルが存在するか確認するよ〜")
        if _, err := os.Stat(filename); err == nil {
                fmt.Printf("✅ %s は存在するよ！\n\n", filename)
        } else if os.IsNotExist(err) {
                fmt.Printf("❌ %s は存在しないよ😢\n\n", filename)
        } else {
                fmt.Printf("⚠️ エラー: %v\n\n", err)
        }

        // 3. ファイルの読み込み 📖
        fmt.Println("3️⃣ ファイルの内容を読み込むよ〜")
        data, err := os.ReadFile(filename)
        if err != nil {
                fmt.Printf("❌ エラー: %v\n", err)
                os.Exit(1)
        }
        fmt.Println("📄 ファイルの内容:")
        fmt.Println("----------------------------------------")
        fmt.Print(string(data))
        fmt.Println("----------------------------------------")
        fmt.Println()

        // 4. ファイル情報を取得 📊
        fmt.Println("4️⃣ ファイル情報を取得するよ〜")
        fileInfo, err := os.Stat(filename)
        if err != nil {
                fmt.Printf("❌ エラー: %v\n", err)
                os.Exit(1)
        }
        fmt.Printf("ファイル名: %s\n", fileInfo.Name())
        fmt.Printf("ファイルサイズ: %d bytes\n", fileInfo.Size())
        fmt.Printf("パーミッション: %s\n", fileInfo.Mode())
        fmt.Printf("最終更新時刻: %s\n", fileInfo.ModTime())
        fmt.Println()

        // 5. ファイルに追記 ➕
        fmt.Println("5️⃣ ファイルに追記するよ〜")
        f, err := os.OpenFile(filename, os.O_APPEND|os.O_WRONLY, 0644)
        if err != nil {
                fmt.Printf("❌ エラー: %v\n", err)
                os.Exit(1)
        }
        defer f.Close()

        appendContent := "追記した内容だよ〜💕\n"
        if _, err := f.WriteString(appendContent); err != nil {
                fmt.Printf("❌ エラー: %v\n", err)
                os.Exit(1)
        }
        fmt.Println("✅ ファイルに追記したよ！")
        fmt.Println()

        // 6. 追記後の内容を確認 👀
        fmt.Println("6️⃣ 追記後の内容を確認するよ〜")
        data, err = os.ReadFile(filename)
        if err != nil {
                fmt.Printf("❌ エラー: %v\n", err)
                os.Exit(1)
        }
        fmt.Println("📄 ファイルの内容:")
        fmt.Println("----------------------------------------")
        fmt.Print(string(data))
        fmt.Println("----------------------------------------")
        fmt.Println()

        // 7. ファイルの削除 🗑️
        fmt.Println("7️⃣ ファイルを削除するよ〜")
        err = os.Remove(filename)
        if err != nil {
                fmt.Printf("❌ エラー: %v\n", err)
                os.Exit(1)
        }
        fmt.Printf("✅ %s を削除したよ！\n", filename)
        fmt.Println()

        fmt.Println("========================================")
        fmt.Println("すべての操作が完了したよ〜！🎉")
}

package main

import (
        "encoding/json"
        "fmt"
        "io"
        "net/http"
        "os"
        "time"
)

// JSONPlaceholder の User 構造体 👤
type User struct {
        ID       int    `json:"id"`
        Name     string `json:"name"`
        Username string `json:"username"`
        Email    string `json:"email"`
        Phone    string `json:"phone"`
        Website  string `json:"website"`
}

func main() {
        fmt.Println("🌐 HTTP クライアントサンプル ✨")
        fmt.Println("========================================")
        fmt.Println()

        // 1. シンプルな GET リクエスト 📡
        fmt.Println("1️⃣ シンプルな GET リクエストを送るよ〜")
        url := "https://jsonplaceholder.typicode.com/users/1"

        resp, err := http.Get(url)
        if err != nil {
                fmt.Printf("❌ リクエスト失敗: %v\n", err)
                os.Exit(1)
        }
        defer resp.Body.Close()

        fmt.Printf("✅ ステータスコード: %d %s\n", resp.StatusCode, resp.Status)
        fmt.Println()

        // 2. レスポンスボディを読み取る 📖
        fmt.Println("2️⃣ レスポンスを読み取るよ〜")
        body, err := io.ReadAll(resp.Body)
        if err != nil {
                fmt.Printf("❌ レスポンス読み取り失敗: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("📄 レスポンスボディ:")
        fmt.Println("----------------------------------------")
        fmt.Println(string(body))
        fmt.Println("----------------------------------------")
        fmt.Println()

        // 3. JSON をパースして構造体に変換 🔄
        fmt.Println("3️⃣ JSON をパースするよ〜")
        var user User
        err = json.Unmarshal(body, &user)
        if err != nil {
                fmt.Printf("❌ JSON パース失敗: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("👤 ユーザー情報:")
        fmt.Printf("  ID: %d\n", user.ID)
        fmt.Printf("  名前: %s\n", user.Name)
        fmt.Printf("  ユーザー名: %s\n", user.Username)
        fmt.Printf("  メール: %s\n", user.Email)
        fmt.Printf("  電話: %s\n", user.Phone)
        fmt.Printf("  ウェブサイト: %s\n", user.Website)
        fmt.Println()

        // 4. カスタム HTTP クライアントでタイムアウト設定 ⏱️
        fmt.Println("4️⃣ タイムアウト付きリクエストを送るよ〜")
        client := &http.Client{
                Timeout: 10 * time.Second, // 10 秒でタイムアウト
        }

        req, err := http.NewRequest("GET", url, nil)
        if err != nil {
                fmt.Printf("❌ リクエスト作成失敗: %v\n", err)
                os.Exit(1)
        }

        // ヘッダーを追加 📋
        req.Header.Set("User-Agent", "Go-CLI-Sample/1.0")
        req.Header.Set("Accept", "application/json")

        resp2, err := client.Do(req)
        if err != nil {
                fmt.Printf("❌ リクエスト失敗: %v\n", err)
                os.Exit(1)
        }
        defer resp2.Body.Close()

        fmt.Printf("✅ ステータスコード: %d\n", resp2.StatusCode)
        fmt.Printf("✅ Content-Type: %s\n", resp2.Header.Get("Content-Type"))
        fmt.Println()

        fmt.Println("========================================")
        fmt.Println("すべてのリクエストが完了したよ〜！🎉")
}

package main

import (
        "encoding/json"
        "fmt"
        "os"
)

// Person 構造体 👤
type Person struct {
        Name     string   `json:"name"`
        Age      int      `json:"age"`
        Email    string   `json:"email"`
        Hobbies  []string `json:"hobbies"`
        IsActive bool     `json:"is_active"`
}

// Config 構造体（ネストした例）⚙️
type Config struct {
        AppName string `json:"app_name"`
        Version string `json:"version"`
        Admin   Person `json:"admin"`
}

func main() {
        fmt.Println("📋 JSON パース・生成サンプル ✨")
        fmt.Println("========================================")
        fmt.Println()

        // 1. JSON 文字列を Go 構造体にデコード 🔄
        fmt.Println("1️⃣ JSON をデコードするよ〜")
        jsonStr := `{
                "name": "ギャルエンジニア",
                "age": 25,
                "email": "gal@example.com",
                "hobbies": ["コーディング", "カフェ巡り", "ショッピング"],
                "is_active": true
        }`

        var person Person
        err := json.Unmarshal([]byte(jsonStr), &person)
        if err != nil {
                fmt.Printf("❌ JSON デコード失敗: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("✅ デコード成功！")
        fmt.Printf("名前: %s\n", person.Name)
        fmt.Printf("年齢: %d\n", person.Age)
        fmt.Printf("メール: %s\n", person.Email)
        fmt.Printf("趣味: %v\n", person.Hobbies)
        fmt.Printf("アクティブ: %v\n", person.IsActive)
        fmt.Println()

        // 2. Go 構造体を JSON にエンコード 🔄
        fmt.Println("2️⃣ 構造体を JSON にエンコードするよ〜")
        newPerson := Person{
                Name:     "イケてるエンジニア",
                Age:      30,
                Email:    "cool@example.com",
                Hobbies:  []string{"Go言語", "OSS開発", "技術ブログ"},
                IsActive: true,
        }

        // コンパクトな JSON（1行）
        jsonData, err := json.Marshal(newPerson)
        if err != nil {
                fmt.Printf("❌ JSON エンコード失敗: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("📄 コンパクトな JSON:")
        fmt.Println(string(jsonData))
        fmt.Println()

        // 3. きれいにフォーマットされた JSON を生成 ✨
        fmt.Println("3️⃣ きれいにフォーマットされた JSON を生成するよ〜")
        prettyJSON, err := json.MarshalIndent(newPerson, "", "  ")
        if err != nil {
                fmt.Printf("❌ JSON エンコード失敗: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("📄 フォーマット済み JSON:")
        fmt.Println(string(prettyJSON))
        fmt.Println()

        // 4. ネストした構造体の JSON 処理 🏗️
        fmt.Println("4️⃣ ネストした構造体を処理するよ〜")
        config := Config{
                AppName: "Go CLI Sample",
                Version: "1.0.0",
                Admin: Person{
                        Name:     "管理者ちゃん",
                        Age:      28,
                        Email:    "admin@example.com",
                        Hobbies:  []string{"サーバー管理", "セキュリティ"},
                        IsActive: true,
                },
        }

        configJSON, err := json.MarshalIndent(config, "", "  ")
        if err != nil {
                fmt.Printf("❌ JSON エンコード失敗: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("📄 ネストした JSON:")
        fmt.Println(string(configJSON))
        fmt.Println()

        // 5. JSON ファイルに保存 💾
        fmt.Println("5️⃣ JSON ファイルに保存するよ〜")
        filename := "config.json"
        err = os.WriteFile(filename, configJSON, 0644)
        if err != nil {
                fmt.Printf("❌ ファイル書き込み失敗: %v\n", err)
                os.Exit(1)
        }
        fmt.Printf("✅ %s に保存したよ！\n", filename)
        fmt.Println()

        // 6. JSON ファイルから読み込み 📖
        fmt.Println("6️⃣ JSON ファイルから読み込むよ〜")
        fileData, err := os.ReadFile(filename)
        if err != nil {
                fmt.Printf("❌ ファイル読み込み失敗: %v\n", err)
                os.Exit(1)
        }

        var loadedConfig Config
        err = json.Unmarshal(fileData, &loadedConfig)
        if err != nil {
                fmt.Printf("❌ JSON デコード失敗: %v\n", err)
                os.Exit(1)
        }

        fmt.Println("✅ ファイルから読み込み成功！")
        fmt.Printf("アプリ名: %s\n", loadedConfig.AppName)
        fmt.Printf("バージョン: %s\n", loadedConfig.Version)
        fmt.Printf("管理者: %s (%s)\n", loadedConfig.Admin.Name, loadedConfig.Admin.Email)
        fmt.Println()

        // 7. クリーンアップ 🧹
        fmt.Println("7️⃣ クリーンアップするよ〜")
        err = os.Remove(filename)
        if err != nil {
                fmt.Printf("⚠️ ファイル削除失敗: %v\n", err)
        } else {
                fmt.Printf("✅ %s を削除したよ！\n", filename)
        }
        fmt.Println()

        fmt.Println("========================================")
        fmt.Println("すべての JSON 操作が完了したよ〜！🎉")
}

package main

import (
        "fmt"
)

// ANSI カラーコード 🎨
const (
        ColorReset  = "\033[0m"
        ColorRed    = "\033[31m"
        ColorGreen  = "\033[32m"
        ColorYellow = "\033[33m"
        ColorBlue   = "\033[34m"
        ColorPurple = "\033[35m"
        ColorCyan   = "\033[36m"
        ColorWhite  = "\033[37m"

        // 背景色 🎭
        BgRed    = "\033[41m"
        BgGreen  = "\033[42m"
        BgYellow = "\033[43m"
        BgBlue   = "\033[44m"
        BgPurple = "\033[45m"
        BgCyan   = "\033[46m"

        // スタイル ✨
        Bold      = "\033[1m"
        Underline = "\033[4m"
        Blink     = "\033[5m"
)

// カラー出力のヘルパー関数 🎨
func colorize(color, text string) string {
        return color + text + ColorReset
}

// 成功メッセージ ✅
func success(message string) {
        fmt.Println(colorize(ColorGreen, "✅ "+message))
}

// エラーメッセージ ❌
func errorMsg(message string) {
        fmt.Println(colorize(ColorRed, "❌ "+message))
}

// 警告メッセージ ⚠️
func warning(message string) {
        fmt.Println(colorize(ColorYellow, "⚠️  "+message))
}

// 情報メッセージ ℹ️
func info(message string) {
        fmt.Println(colorize(ColorBlue, "ℹ️  "+message))
}

func main() {
        fmt.Println("🌈 カラフルな出力サンプル ✨")
        fmt.Println("========================================")
        fmt.Println()

        // 1. 基本的な色 🎨
        fmt.Println("1️⃣ 基本的な色を表示するよ〜")
        fmt.Println(colorize(ColorRed, "赤色のテキスト"))
        fmt.Println(colorize(ColorGreen, "緑色のテキスト"))
        fmt.Println(colorize(ColorYellow, "黄色のテキスト"))
        fmt.Println(colorize(ColorBlue, "青色のテキスト"))
        fmt.Println(colorize(ColorPurple, "紫色のテキスト"))
        fmt.Println(colorize(ColorCyan, "シアン色のテキスト"))
        fmt.Println(colorize(ColorWhite, "白色のテキスト"))
        fmt.Println()

        // 2. スタイル付きテキスト ✨
        fmt.Println("2️⃣ スタイルを適用するよ〜")
        fmt.Println(colorize(Bold, "太字のテキスト"))
        fmt.Println(colorize(Underline, "下線付きテキスト"))
        fmt.Println(colorize(Bold+ColorRed, "太字の赤色テキスト"))
        fmt.Println(colorize(Bold+Underline+ColorBlue, "太字＋下線＋青色"))
        fmt.Println()

        // 3. 背景色 🎭
        fmt.Println("3️⃣ 背景色を設定するよ〜")
        fmt.Println(colorize(BgRed+ColorWhite, " 赤い背景 "))
        fmt.Println(colorize(BgGreen+ColorWhite, " 緑の背景 "))
        fmt.Println(colorize(BgYellow+ColorWhite, " 黄色の背景 "))
        fmt.Println(colorize(BgBlue+ColorWhite, " 青い背景 "))
        fmt.Println(colorize(BgPurple+ColorWhite, " 紫の背景 "))
        fmt.Println(colorize(BgCyan+ColorWhite, " シアンの背景 "))
        fmt.Println()

        // 4. 実用的な使い方 💼
        fmt.Println("4️⃣ 実用的なメッセージ表示だよ〜")
        success("処理が成功したよ！")
        errorMsg("エラーが発生したよ😢")
        warning("これは警告メッセージだよ！")
        info("お知らせがあるよ〜")
        fmt.Println()

        // 5. 組み合わせ例 🎨
        fmt.Println("5️⃣ いろんな組み合わせ例だよ〜")
        fmt.Printf("%s %s %s\n",
                colorize(ColorRed, "エラー:"),
                "ファイルが見つからないよ😢",
                colorize(ColorYellow, "(code: 404)"))

        fmt.Printf("%s %s %s\n",
                colorize(Bold+ColorGreen, "成功!"),
                "ビルドが完了したよ〜",
                colorize(ColorCyan, "(0.5秒)"))

        fmt.Printf("%s %s\n",
                colorize(Bold+ColorBlue, "📊 進捗:"),
                colorize(ColorGreen, "████████") + colorize(ColorWhite, "░░") + " 80%")
        fmt.Println()

        // 6. レインボー表示 🌈
        fmt.Println("6️⃣ レインボー表示だよ〜")
        rainbow := []string{ColorRed, ColorYellow, ColorGreen, ColorCyan, ColorBlue, ColorPurple}
        text := "カラフル！"
        for i, char := range text {
                color := rainbow[i%len(rainbow)]
                fmt.Print(colorize(color, string(char)))
        }
        fmt.Println()
        fmt.Println()

        fmt.Println("========================================")
        fmt.Println(colorize(Bold+ColorGreen, "すべてのカラー表示が完了したよ〜！🎉"))
}

package main

import (
        "fmt"
        "time"
)

// カラーコード 🎨
const (
        ColorReset = "\033[0m"
        ColorGreen = "\033[32m"
        ColorCyan  = "\033[36m"
        ColorWhite = "\033[37m"
)

// シンプルなプログレスバーを表示 📊
func simpleProgressBar(percent int) {
        barLength := 50
        filled := percent * barLength / 100
        empty := barLength - filled

        bar := ""
        for i := 0; i < filled; i++ {
                bar += "█"
        }
        for i := 0; i < empty; i++ {
                bar += "░"
        }

        // \r でカーソルを行頭に戻して上書き 🔄
        fmt.Printf("\r[%s] %d%%", bar, percent)
}

// カラフルなプログレスバーを表示 🌈
func colorfulProgressBar(percent int) {
        barLength := 50
        filled := percent * barLength / 100
        empty := barLength - filled

        bar := ColorGreen
        for i := 0; i < filled; i++ {
                bar += "█"
        }
        bar += ColorWhite
        for i := 0; i < empty; i++ {
                bar += "░"
        }
        bar += ColorReset

        // 進捗に応じてメッセージを変える 💬
        var status string
        switch {
        case percent < 25:
                status = "開始中..."
        case percent < 50:
                status = "進行中..."
        case percent < 75:
                status = "もうちょい！"
        case percent < 100:
                status = "あと少し！"
        default:
                status = "完了！✨"
        }

        fmt.Printf("\r[%s] %d%% - %s", bar, percent, status)
}

// スピナーアニメーション 🔄
func spinner(message string, duration time.Duration) {
        spinChars := []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
        start := time.Now()

        i := 0
        for time.Since(start) < duration {
                fmt.Printf("\r%s %s", spinChars[i%len(spinChars)], message)
                i++
                time.Sleep(100 * time.Millisecond)
        }
        fmt.Printf("\r✅ %s - 完了！\n", message)
}

// ダウンロード風プログレスバー 📥
func downloadProgressBar(current, total int) {
        percent := current * 100 / total
        barLength := 30
        filled := percent * barLength / 100

        bar := ColorCyan
        for i := 0; i < filled; i++ {
                bar += "="
        }
        if filled < barLength {
                bar += ">"
                filled++
        }
        bar += ColorWhite
        for i := filled; i < barLength; i++ {
                bar += " "
        }
        bar += ColorReset

        // サイズを MB で表示
        currentMB := float64(current) / 1024.0
        totalMB := float64(total) / 1024.0

        fmt.Printf("\rダウンロード中: [%s] %d%% (%.1f/%.1f MB)", bar, percent, currentMB, totalMB)
}

func main() {
        fmt.Println("⏳ プログレスバーサンプル ✨")
        fmt.Println("========================================")
        fmt.Println()

        // 1. シンプルなプログレスバー 📊
        fmt.Println("1️⃣ シンプルなプログレスバー")
        for i := 0; i <= 100; i++ {
                simpleProgressBar(i)
                time.Sleep(30 * time.Millisecond)
        }
        fmt.Println() // 改行
        fmt.Println()

        // 2. カラフルなプログレスバー 🌈
        fmt.Println("2️⃣ カラフルなプログレスバー")
        for i := 0; i <= 100; i++ {
                colorfulProgressBar(i)
                time.Sleep(30 * time.Millisecond)
        }
        fmt.Println() // 改行
        fmt.Println()

        // 3. スピナーアニメーション 🔄
        fmt.Println("3️⃣ スピナーアニメーション")
        spinner("データを処理中", 2*time.Second)
        spinner("ファイルを読み込み中", 2*time.Second)
        spinner("サーバーに接続中", 2*time.Second)
        fmt.Println()

        // 4. ダウンロード風プログレスバー 📥
        fmt.Println("4️⃣ ダウンロード風プログレスバー")
        total := 10240 // 10 MB
        for i := 0; i <= total; i += 128 {
                downloadProgressBar(i, total)
                time.Sleep(20 * time.Millisecond)
        }
        downloadProgressBar(total, total) // 最後に 100% を表示
        fmt.Println() // 改行
        fmt.Println()

        // 5. マルチステッププログレス 📝
        fmt.Println("5️⃣ マルチステッププログレス")
        steps := []string{
                "依存関係をインストール中",
                "ソースコードをコンパイル中",
                "テストを実行中",
                "ビルド成果物を作成中",
                "デプロイ中",
        }

        for _, step := range steps {
                spinner(step, 1*time.Second)
        }
        fmt.Println()

        fmt.Println("========================================")
        fmt.Println(ColorGreen + "すべての処理が完了したよ〜！🎉" + ColorReset)
}

package main

import (
        "fmt"
        "strings"
)

// カラーコード 🎨
const (
        ColorReset  = "\033[0m"
        ColorGreen  = "\033[32m"
        ColorYellow = "\033[33m"
        ColorCyan   = "\033[36m"
        Bold        = "\033[1m"
)

// データ構造 📊
type User struct {
        ID     int
        Name   string
        Email  string
        Status string
}

// シンプルなテーブルを表示 📋
func printSimpleTable(users []User) {
        // ヘッダー
        fmt.Println("ID\tName\t\t\tEmail\t\t\t\tStatus")
        fmt.Println(strings.Repeat("-", 80))

        // データ行
        for _, user := range users {
                fmt.Printf("%d\t%-20s\t%-30s\t%s\n", user.ID, user.Name, user.Email, user.Status)
        }
}

// 罫線付きテーブルを表示 📦
func printBoxedTable(users []User) {
        // 列幅を定義
        idWidth := 6
        nameWidth := 25
        emailWidth := 30
        statusWidth := 10

        // 上部の罫線
        fmt.Printf("┌%s┬%s┬%s┬%s┐\n",
                strings.Repeat("─", idWidth),
                strings.Repeat("─", nameWidth),
                strings.Repeat("─", emailWidth),
                strings.Repeat("─", statusWidth))

        // ヘッダー
        fmt.Printf("│ %-*s │ %-*s │ %-*s │ %-*s │\n",
                idWidth-2, "ID",
                nameWidth-2, "Name",
                emailWidth-2, "Email",
                statusWidth-2, "Status")

        // ヘッダーとデータの区切り線
        fmt.Printf("├%s┼%s┼%s┼%s┤\n",
                strings.Repeat("─", idWidth),
                strings.Repeat("─", nameWidth),
                strings.Repeat("─", emailWidth),
                strings.Repeat("─", statusWidth))

        // データ行
        for _, user := range users {
                name := truncate(user.Name, nameWidth-3)
                email := truncate(user.Email, emailWidth-3)
                status := truncate(user.Status, statusWidth-3)

                fmt.Printf("│ %-*d │ %-*s │ %-*s │ %-*s │\n",
                        idWidth-2, user.ID,
                        nameWidth-2, name,
                        emailWidth-2, email,
                        statusWidth-2, status)
        }

        // 下部の罫線
        fmt.Printf("└%s┴%s┴%s┴%s┘\n",
                strings.Repeat("─", idWidth),
                strings.Repeat("─", nameWidth),
                strings.Repeat("─", emailWidth),
                strings.Repeat("─", statusWidth))
}

// カラフルなテーブルを表示 🌈
func printColorfulTable(users []User) {
        // 列幅を定義
        idWidth := 6
        nameWidth := 25
        emailWidth := 30
        statusWidth := 10

        // ヘッダー（太字＋シアン）
        header := Bold + ColorCyan
        fmt.Printf("%s┌%s┬%s┬%s┬%s┐%s\n",
                header,
                strings.Repeat("─", idWidth),
                strings.Repeat("─", nameWidth),
                strings.Repeat("─", emailWidth),
                strings.Repeat("─", statusWidth),
                ColorReset)

        fmt.Printf("%s│ %-*s │ %-*s │ %-*s │ %-*s │%s\n",
                header,
                idWidth-2, "ID",
                nameWidth-2, "Name",
                emailWidth-2, "Email",
                statusWidth-2, "Status",
                ColorReset)

        fmt.Printf("%s├%s┼%s┼%s┼%s┤%s\n",
                header,
                strings.Repeat("─", idWidth),
                strings.Repeat("─", nameWidth),
                strings.Repeat("─", emailWidth),
                strings.Repeat("─", statusWidth),
                ColorReset)

        // データ行（ステータスに応じて色分け）
        for _, user := range users {
                name := truncate(user.Name, nameWidth-3)
                email := truncate(user.Email, emailWidth-3)

                // ステータスの色を決定
                var statusColor string
                switch user.Status {
                case "Active":
                        statusColor = ColorGreen
                case "Pending":
                        statusColor = ColorYellow
                default:
                        statusColor = ColorReset
                }

                fmt.Printf("│ %-*d │ %-*s │ %-*s │ %s%-*s%s │\n",
                        idWidth-2, user.ID,
                        nameWidth-2, name,
                        emailWidth-2, email,
                        statusColor, statusWidth-2, user.Status, ColorReset)
        }

        // 下部の罫線
        fmt.Printf("%s└%s┴%s┴%s┴%s┘%s\n",
                header,
                strings.Repeat("─", idWidth),
                strings.Repeat("─", nameWidth),
                strings.Repeat("─", emailWidth),
                strings.Repeat("─", statusWidth),
                ColorReset)
}

// 文字列を指定した長さに切り詰める ✂️
func truncate(s string, maxLen int) string {
        if len(s) <= maxLen {
                return s
        }
        return s[:maxLen-3] + "..."
}

func main() {
        fmt.Println("📊 テーブル出力サンプル ✨")
        fmt.Println("========================================")
        fmt.Println()

        // サンプルデータ
        users := []User{
                {1, "ギャルエンジニア", "gal@example.com", "Active"},
                {2, "イケてるデベロッパー", "cool-dev@example.com", "Active"},
                {3, "かわいいプログラマー", "kawaii-prog@example.com", "Pending"},
                {4, "スーパーハッカー", "super-hacker@example.com", "Active"},
                {5, "最強エンジニア", "saikyo-eng@example.com", "Inactive"},
        }

        // 1. シンプルなテーブル 📋
        fmt.Println("1️⃣ シンプルなテーブル")
        printSimpleTable(users)
        fmt.Println()

        // 2. 罫線付きテーブル 📦
        fmt.Println("2️⃣ 罫線付きテーブル")
        printBoxedTable(users)
        fmt.Println()

        // 3. カラフルなテーブル 🌈
        fmt.Println("3️⃣ カラフルなテーブル")
        printColorfulTable(users)
        fmt.Println()

        // 4. サマリー表示 📊
        fmt.Println("4️⃣ サマリー")
        activeCount := 0
        pendingCount := 0
        inactiveCount := 0

        for _, user := range users {
                switch user.Status {
                case "Active":
                        activeCount++
                case "Pending":
                        pendingCount++
                case "Inactive":
                        inactiveCount++
                }
        }

        fmt.Printf("総ユーザー数: %d\n", len(users))
        fmt.Printf("%sアクティブ%s: %d\n", ColorGreen, ColorReset, activeCount)
        fmt.Printf("%sペンディング%s: %d\n", ColorYellow, ColorReset, pendingCount)
        fmt.Printf("非アクティブ: %d\n", inactiveCount)
        fmt.Println()

        fmt.Println("========================================")
        fmt.Println(ColorGreen + "すべてのテーブル表示が完了したよ〜！🎉" + ColorReset)
}