package main

import (
    "log"
    "os"
    "github.com/slack-go/slack"
)

func main() {
    // Slack APIトークンを環境変数から取得
    token := os.Getenv("SLACK_BOT_TOKEN")
    if token == "" {
        log.Fatal("SLACK_BOT_TOKEN is not set")
    }

    // Slackクライアントの初期化
    api := slack.New(token)
}

func getUsers(api *slack.Client) {
    // ユーザー一覧を取得
    users, err := api.GetUsers()
    if err != nil {
        log.Fatalf("ユーザー一覧の取得に失敗しました: %v", err)
    }

    // ユーザー情報を表示
    log.Printf("ワークスペース内のユーザー数: %d\n", len(users))
    for i, user := range users {
        // 必要な情報だけを表示（すべての情報を表示するとログが長くなりすぎるため）
        log.Printf("%d: ID=%s, Name=%s, RealName=%s, IsBot=%v\n",
            i+1, user.ID, user.Name, user.RealName, user.IsBot)
    }
}

func sendDirectMessage(api *slack.Client, userID, message string) error {
    // ユーザーとのDMチャンネルを開く
    channel, _, _, err := api.OpenConversation(&slack.OpenConversationParameters{
        Users: []string{userID},
    })
    if err != nil {
        return fmt.Errorf("DMチャンネルを開けませんでした: %v", err)
    }

    // DMを送信
    _, _, err = api.PostMessage(
        channel.ID,
        slack.MsgOptionText(message, false),
    )
    if err != nil {
        return fmt.Errorf("DMの送信に失敗しました: %v", err)
    }

    log.Printf("ユーザー %s にDMを送信しました", userID)
    return nil
}

func buildSampleBlockKit() slack.MsgOption {
    // Block Kitを使ったメッセージの構築
    headerText := slack.NewTextBlockObject("mrkdwn", "*ブロックキットのサンプル*", false, false)
    headerSection := slack.NewSectionBlock(headerText, nil, nil)

    // テキストブロック
    textBlock := slack.NewTextBlockObject("mrkdwn", "これは `Block Kit` を使ったメッセージです。\n*太字* や _斜体_ などのMarkdownも使えます！", false, false)
    textSection := slack.NewSectionBlock(textBlock, nil, nil)

    // 画像ブロック
    accessory := slack.NewImageBlockElement("https://api.slack.com/img/blocks/bkb_template_images/beagle.png", "犬の画像")
    imageText := slack.NewTextBlockObject("mrkdwn", "こちらはかわいい犬の画像です :dog:", false, false)
    imageSection := slack.NewSectionBlock(imageText, nil, slack.NewAccessory(accessory))

    // ボタン要素
    btnText := slack.NewTextBlockObject("plain_text", "クリックしてください", false, false)
    btn := slack.NewButtonBlockElement("click_button", "button_clicked", btnText)
    btnAccessory := slack.NewAccessory(btn)

    // ボタンセクション
    btnSectionText := slack.NewTextBlockObject("mrkdwn", "アクションを実行するには:", false, false)
    btnSection := slack.NewSectionBlock(btnSectionText, nil, btnAccessory)

    // 区切り線
    divider := slack.NewDividerBlock()

    // フッターブロック
    footerText := slack.NewTextBlockObject("mrkdwn", "Block Kitの詳細は <https://api.slack.com/block-kit|こちら> をご覧ください", false, false)
    footerSection := slack.NewSectionBlock(footerText, nil, nil)

    // すべてのブロックを一つのメッセージにまとめる
    return slack.MsgOptionBlocks(
        headerSection,
        divider,
        textSection,
        imageSection,
        divider,
        btnSection,
        divider,
        footerSection,
    )
}

func sendDirectMessageWithBlocks(api *slack.Client, userID string, blocks slack.MsgOption) error {
    // ユーザーとのDMチャンネルを開く
    channel, _, _, err := api.OpenConversation(&slack.OpenConversationParameters{
        Users: []string{userID},
    })
    if err != nil {
        return fmt.Errorf("DMチャンネルを開けませんでした: %v", err)
    }

    // ブロックキットメッセージを送信
    _, _, err = api.PostMessage(
        channel.ID,
        blocks,
    )
    if err != nil {
        return fmt.Errorf("DMの送信に失敗しました: %v", err)
    }

    log.Printf("ユーザー %s にブロックキットDMを送信しました", userID)
    return nil
}

func main() {
    // Slack APIトークンを環境変数から取得
    token := os.Getenv("SLACK_BOT_TOKEN")
    if token == "" {
        log.Fatal("SLACK_BOT_TOKEN is not set")
    }

    // Slackクライアントの初期化
    api := slack.New(token)

    // ユーザー一覧を取得して表示
    getUsers(api)

    // 特定のユーザーにDMを送信
    userID := "U02K6JU8D" // 実際のユーザーIDに置き換えてください
    err := sendDirectMessage(api, userID, "これはテストメッセージです！")
    if err != nil {
        log.Fatalf("DMの送信に失敗しました: %v", err)
    }

    // ブロックキットを使用したDMを送信
    blocks := buildSampleBlockKit()
    err = sendDirectMessageWithBlocks(api, userID, blocks)
    if err != nil {
        log.Fatalf("ブロックキットDMの送信に失敗しました: %v", err)
    }
}

// limiter/limiter.go
package limiter

import (
    "fmt"
    "time"
)

// レート制限を確認し、エラーを返す
type Limiter interface {
    Check() error
}

// RateLimitErrorは、レート制限が超過されたときに発生するエラー
type RateLimitError struct {
    RetryIn time.Duration
}

func (e *RateLimitError) Error() string {
    return fmt.Sprintf("rate limited (retry in %v)", e.RetryIn)
}

// limiter/rate_limiter.go
type RateLimiter struct {
    limiter *rate.Limiter
    limit   int           // 1秒間に処理できるリクエスト数
    burst   int           // 瞬間的に許可される最大リクエスト数
    retryIn time.Duration // レート制限時の再試行待機時間
}

func NewRateLimiter(limit int, burst int, retryIn time.Duration) *RateLimiter {
    return &RateLimiter{
        limiter: rate.NewLimiter(rate.Limit(limit), burst),
        limit:   limit,
        burst:   burst,
        retryIn: retryIn,
    }
}

func (rl *RateLimiter) Check() error {
    if !rl.limiter.Allow() {
        return &RateLimitError{
            RetryIn: rl.retryIn,
        }
    }
    return nil
}

// limiter/redis_rate_limiterv2.go
type RedisRateLimiterV2 struct {
    client     *redis.Client
    key        string
    limit      int
    windowSize time.Duration
}

func (r *RedisRateLimiterV2) Allow(taskType string) (bool, int64, error) {
    ctx := context.Background()
    key := fmt.Sprintf("rate_limit:%s", taskType)
    now := time.Now().Unix()

    script := `
        local key = KEYS[1]
        local limit = tonumber(ARGV[1])
        local window = tonumber(ARGV[2])
        local now = tonumber(ARGV[3])

        -- 古いエントリを削除
        redis.call("ZREMRANGEBYSCORE", key, "-inf", now - window)

        -- 現在のリクエスト数を取得
        local count = redis.call("ZCOUNT", key, "-inf", "+inf")

        if count >= limit then
            -- 最も古いリクエストのタイムスタンプを取得
            local oldest = redis.call("ZRANGE", key, 0, 0, "WITHSCORES")
            local retryIn = 0.0
            if #oldest > 0 then
                retryIn = math.max(0, oldest[2] + window - now)
            end
            return {0, retryIn}
        end

        -- 新しいリクエストを追加
        redis.call("ZADD", key, now, tostring(now) .. "-" .. redis.call("INCR", "request_counter"))
        redis.call("EXPIRE", key, window)

        return {1, 0}
    `

    result, err := r.client.Eval(ctx, script, []string{key}, r.limit, int(r.windowSize.Seconds()), now).Result()
    // ... エラーハンドリングと結果の解析
}

// tasks/tasks.go
func EmailNotificationTask(ctx context.Context, t *asynq.Task, limit limiter.Limiter) error {
    // レート制限を確認
    if err := limit.Check(); err != nil {
        return err
    }

    // メール送信処理
    var payload map[string]string
    if err := json.Unmarshal(t.Payload(), &payload); err != nil {
        return err
    }
    log.Println("Sending Email to:", payload["email"], "with subject:", payload["subject"])
    return nil
}

// worker/main.go
func main() {
    // 1秒間1リクエストに制限
    emailRateLimiter := limiter.NewRedisRateLimiterV2("email", 1, time.Second)

    srv := asynq.NewServer(
        asynq.RedisClientOpt{Addr: ":6379"},
        asynq.Config{
            Concurrency: 5,
            Queues: map[string]int{
                "default": 7,
                "email":   3,
            },
            // レート制限エラーを失敗としてカウントしない
            IsFailure: func(err error) bool { 
                return !IsRateLimitError(err) 
            },
            // 再試行の間隔を指定
            RetryDelayFunc: retryDelay,
            DelayedTaskCheckInterval: 100 * time.Millisecond,
        },
    )

    mux := asynq.NewServeMux()
    mux.HandleFunc(tasks.TypeEmailTask, func(ctx context.Context, t *asynq.Task) error {
        // TaskにRateLimiterを設定する
        return tasks.EmailNotificationTask(ctx, t, emailRateLimiter)
    })

    if err := srv.Run(mux); err != nil {
        log.Fatalf("サーバーを起動できませんでした: %v", err)
    }
}

// レート制限エラーの判定
func IsRateLimitError(err error) bool {
    _, ok := err.(*limiter.RateLimitError)
    return ok
}

// カスタムリトライ遅延
func retryDelay(n int, err error, task *asynq.Task) time.Duration {
    var ratelimitErr *limiter.RateLimitError
    if errors.As(err, &ratelimitErr) {
        return ratelimitErr.RetryIn
    }
    return asynq.DefaultRetryDelayFunc(n, err, task)
}

srv := asynq.NewServer(
    redisOpt,
    asynq.Config{
        // レート制限エラーは失敗としてカウントしない
        IsFailure: func(err error) bool { 
            return !IsRateLimitError(err) 
        },
        // レート制限エラーの場合は適切な待機時間でリトライ
        RetryDelayFunc: retryDelay,
    },
)

package main

import (
	"errors"
	"fmt"
)

// カスタムエラー型の定義
var (
	ErrNotFound = errors.New("not found")
	ErrInvalid  = errors.New("invalid input")
)

// データベース操作を模擬する関数
func findUser(id string) error {
	// エラーをラップして返す
	return fmt.Errorf("failed to find user: %w", ErrNotFound)
}

type NotFoundError struct {
	ID string
}

func (e *NotFoundError) Error() string {
	return fmt.Sprintf("user %s not found", e.ID)
}

func main() {
	// 悪い例: == 演算子での比較
	err := findUser("123")
	if err == ErrNotFound { // これは動作しない！
		fmt.Println("== で比較。ユーザーが見つかりませんでした")
	}

	// 良い例1: errors.Is() を使用
	err = findUser("123")
	if errors.Is(err, ErrNotFound) {
		fmt.Println("errors.Is() で比較。ユーザーが見つかりませんでした")
	}

	err = &NotFoundError{ID: "123"}
	var notFoundErr *NotFoundError
	if errors.As(err, &notFoundErr) {
		fmt.Printf("ユーザー %s が見つかりませんでした\n", notFoundErr.ID)
	}

	// エラーのラップと展開の例
	err = findUser("123")
	fmt.Printf("元のエラー: %v\n", err)

	// ラップされたエラーを展開
	unwrapped := errors.Unwrap(err)
	fmt.Printf("展開されたエラー: %v\n", unwrapped)
}

// 悪い例: == 演算子での比較
err := findUser("123")
if err == ErrNotFound { // これは動作しない！
    fmt.Println("== で比較。ユーザーが見つかりませんでした")
}

// 良い例1: errors.Is() を使用
err = findUser("123")
if errors.Is(err, ErrNotFound) {
    fmt.Println("errors.Is() で比較。ユーザーが見つかりませんでした")
}

err = &NotFoundError{ID: "123"}
var notFoundErr *NotFoundError
if errors.As(err, &notFoundErr) {
    fmt.Printf("ユーザー %s が見つかりませんでした\n", notFoundErr.ID)
}

// エラーのラップと展開の例
err = findUser("123")
fmt.Printf("元のエラー: %v\n", err)

// ラップされたエラーを展開
unwrapped := errors.Unwrap(err)
fmt.Printf("展開されたエラー: %v\n", unwrapped)

type NotFoundError struct {
    ID string
}

func (e *NotFoundError) Error() string {
    return fmt.Sprintf("user %s not found", e.ID)
}