import okhttp3.*;
import com.alibaba.fastjson.JSONObject;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;

@Component
public class WxWorkMsgSender {
    // 緩存access_token（生產環境替換為Redis/Guava Cache）
    private String accessToken;
    private long tokenExpireTime;

    // 初始化OkHttp客戶端（全局單例）
    private final OkHttpClient okHttpClient = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .readTimeout(10, TimeUnit.SECONDS)
            .retryOnConnectionFailure(true)
            .build();

    // 獲取AccessToken（帶緩存）
    private String getValidAccessToken() {
        long now = System.currentTimeMillis();
        if (accessToken == null || now > tokenExpireTime) {
            // 調用企微gettoken接口，此處省略實現
            accessToken = fetchTokenFromWxWork();
            tokenExpireTime = now + 70 * 60 * 1000; // 70分鐘過期
        }
        return accessToken;
    }

    // 發送外部群文本消息
    public boolean sendExternalGroupMsg(String chatId, String content) {
        String url = "https://qyapi.weixin.qq.com/cgi-bin/appchat/send?access_token=" + getValidAccessToken();
        
        // 構建消息體
        JSONObject msgJson = new JSONObject();
        msgJson.put("chatid", chatId);
        msgJson.put("msgtype", "text");
        JSONObject textContent = new JSONObject();
        textContent.put("content", content);
        msgJson.put("text", textContent);
        msgJson.put("agentid", 1000002); // 替換為你的AgentID

        // 構建請求
        Request request = new Request.Builder()
                .url(url)
                .post(RequestBody.create(MediaType.parse("application/json; charset=utf-8"), msgJson.toJSONString()))
                .build();

        try (Response response = okHttpClient.newCall(request).execute()) {
            String respBody = response.body().string();
            JSONObject respJson = JSONObject.parseObject(respBody);
            if (respJson.getInteger("errcode") == 0) {
                return true;
            } else {
                // 處理異常：401刷新token重試，429延遲重試
                int errCode = respJson.getInteger("errcode");
                if (errCode == 401) {
                    accessToken = null; // 清空緩存，下次自動刷新
                    return sendExternalGroupMsg(chatId, content); // 重試1次
                } else if (errCode == 429) {
                    TimeUnit.SECONDS.sleep(2); // 延遲2秒重試
                    return sendExternalGroupMsg(chatId, content);
                }
                System.err.println("發送失敗：" + respJson.getString("errmsg"));
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 實際調用企微gettoken接口的方法（需替換corpid和corpsecret）
    private String fetchTokenFromWxWork() {
        String corpid = "你的企業ID";
        String corpsecret = "你的應用秘鑰";
        String tokenUrl = String.format("https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s", corpid, corpsecret);
        Request request = new Request.Builder().url(tokenUrl).get().build();
        try (Response response = okHttpClient.newCall(request).execute()) {
            String respBody = response.body().string();
            JSONObject respJson = JSONObject.parseObject(respBody);
            return respJson.getString("access_token");
        } catch (Exception e) {
            throw new RuntimeException("獲取AccessToken失敗", e);
        }
    }
}

package main

import (
	"context"
	"encoding/json"
	"fmt"
	"net/http"
	"sync"
	"time"
)

// 全局AccessToken緩存
var (
	tokenCache struct {
		sync.RWMutex
		token     string
		expiresAt time.Time
	}
	client = &http.Client{Timeout: 10 * time.Second}
)

// 企微API響應結構體
type WxWorkResp struct {
	Errcode int    `json:"errcode"`
	Errmsg  string `json:"errmsg"`
}

// 文本消息結構體
type TextMsg struct {
	Chatid  string `json:"chatid"`
	Msgtype string `json:"msgtype"`
	Agentid int    `json:"agentid"`
	Text    struct {
		Content string `json:"content"`
	} `json:"text"`
}

// 獲取有效的AccessToken
func getAccessToken() (string, error) {
	tokenCache.RLock()
	if time.Now().Before(tokenCache.expiresAt) {
		token := tokenCache.token
		tokenCache.RUnlock()
		return token, nil
	}
	tokenCache.RUnlock()

	// 加寫鎖刷新token
	tokenCache.Lock()
	defer tokenCache.Unlock()
	// 雙重檢查，避免多協程重復刷新
	if time.Now().Before(tokenCache.expiresAt) {
		return tokenCache.token, nil
	}

	// 調用企微gettoken接口
	corpid := "你的企業ID"
	corpsecret := "你的應用秘鑰"
	url := fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=%s&corpsecret=%s", corpid, corpsecret)
	resp, err := client.Get(url)
	if err != nil {
		return "", fmt.Errorf("獲取token失敗：%v", err)
	}
	defer resp.Body.Close()

	var tokenResp struct {
		Errcode     int    `json:"errcode"`
		Errmsg      string `json:"errmsg"`
		AccessToken string `json:"access_token"`
		ExpiresIn   int    `json:"expires_in"`
	}
	if err := json.NewDecoder(resp.Body).Decode(&tokenResp); err != nil {
		return "", fmt.Errorf("解析token響應失敗：%v", err)
	}
	if tokenResp.Errcode != 0 {
		return "", fmt.Errorf("企微返回錯誤：%s", tokenResp.Errmsg)
	}

	// 更新緩存（過期時間減10分鐘，預留緩沖）
	tokenCache.token = tokenResp.AccessToken
	tokenCache.expiresAt = time.Now().Add(time.Duration(tokenResp.ExpiresIn-600) * time.Second)
	return tokenResp.AccessToken, nil
}

// 發送外部群消息（帶上下文超時）
func sendExternalGroupMsg(ctx context.Context, chatId, content string) bool {
	token, err := getAccessToken()
	if err != nil {
		fmt.Printf("獲取token失敗：%v\n", err)
		return false
	}

	url := fmt.Sprintf("https://qyapi.weixin.qq.com/cgi-bin/appchat/send?access_token=%s", token)
	msg := TextMsg{
		Chatid:  chatId,
		Msgtype: "text",
		Agentid: 1000002, // 替換為你的AgentID
	}
	msg.Text.Content = content

	// 序列化消息體
	msgBytes, err := json.Marshal(msg)
	if err != nil {
		fmt.Printf("序列化消息失敗：%v\n", err)
		return false
	}

	// 構建請求（帶上下文超時）
	req, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(msgBytes))
	if err != nil {
		fmt.Printf("構建請求失敗：%v\n", err)
		return false
	}
	req.Header.Set("Content-Type", "application/json; charset=utf-8")

	resp, err := client.Do(req)
	if err != nil {
		fmt.Printf("發送請求失敗：%v\n", err)
		return false
	}
	defer resp.Body.Close()

	var wxResp WxWorkResp
	if err := json.NewDecoder(resp.Body).Decode(&wxResp); err != nil {
		fmt.Printf("解析響應失敗：%v\n", err)
		return false
	}

	if wxResp.Errcode == 0 {
		return true
	}
	// 處理429限流：延遲重試（最多1次）
	if wxResp.Errcode == 429 {
		time.Sleep(2 * time.Second)
		return sendExternalGroupMsg(ctx, chatId, content)
	}
	fmt.Printf("發送失敗：%s（code：%d）\n", wxResp.Errmsg, wxResp.Errcode)
	return false
}

// 批量發送（控制并發數）
func batchSend(chatIds []string, content string, maxConcurrency int) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()

	ch := make(chan string, maxConcurrency)
	var wg sync.WaitGroup

	// 啟動協程池
	for i := 0; i < maxConcurrency; i++ {
		go func() {
			for chatId := range ch {
				sendExternalGroupMsg(ctx, chatId, content)
				wg.Done()
			}
		}()
	}

	// 分發任務
	for _, chatId := range chatIds {
		wg.Add(1)
		ch <- chatId
	}
	close(ch)
	wg.Wait()
}

func main() {
	// 示例：批量發送給5個外部群，最大并發5
	chatIds := []string{"chat123456", "chat789012"}
	batchSend(chatIds, "【通知】企業服務升級提醒", 5)
}

import aiohttp
import asyncio
import json
import time
from functools import lru_cache

# 配置項
CORPID = "你的企業ID"
CORPSECRET = "你的應用秘鑰"
AGENTID = 1000002
MAX_RETRY = 1  # 最大重試次數
CONCURRENCY = 5  # 異步并發數

# 緩存AccessToken（lru_cache默認按參數緩存，此處無參數，緩存全局）
@lru_cache(maxsize=1)
def get_access_token():
    """獲取AccessToken（緩存70分鐘）"""
    url = f"https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid={CORPID}&corpsecret={CORPSECRET}"
    try:
        resp = aiohttp.ClientSession().get(url, timeout=10)
        resp_json = resp.json()
        if resp_json["errcode"] != 0:
            raise Exception(f"獲取token失敗：{resp_json['errmsg']}")
        # 記錄緩存時間，70分鐘后失效
        token = resp_json["access_token"]
        # 用lru_cache的過期機制（此處簡單處理，實際可加時間判斷）
        asyncio.get_event_loop().call_later(70*60, lambda: get_access_token.cache_clear())
        return token
    except Exception as e:
        print(f"獲取AccessToken異常：{e}")
        raise

async def send_external_group_msg(session, chat_id: str, content: str, retry=0):
    """異步發送外部群消息"""
    if retry > MAX_RETRY:
        print(f"[{chat_id}] 重試次數耗盡，發送失敗")
        return False
    
    try:
        token = get_access_token()
        url = f"https://qyapi.weixin.qq.com/cgi-bin/appchat/send?access_token={token}"
        msg = {
            "chatid": chat_id,
            "msgtype": "text",
            "agentid": AGENTID,
            "text": {"content": content}
        }
        async with session.post(url, json=msg, timeout=10) as resp:
            resp_json = await resp.json()
            if resp_json["errcode"] == 0:
                print(f"[{chat_id}] 發送成功")
                return True
            elif resp_json["errcode"] == 429:
                # 限流，延遲1秒重試
                print(f"[{chat_id}] 觸發限流，重試第{retry+1}次")
                await asyncio.sleep(1)
                return await send_external_group_msg(session, chat_id, content, retry+1)
            elif resp_json["errcode"] == 401:
                # token失效，清空緩存重試
                get_access_token.cache_clear()
                return await send_external_group_msg(session, chat_id, content, retry+1)
            else:
                print(f"[{chat_id}] 發送失敗：{resp_json['errmsg']}（code：{resp_json['errcode']}）")
                return False
    except Exception as e:
        print(f"[{chat_id}] 發送異常：{e}，重試第{retry+1}次")
        await asyncio.sleep(1)
        return await send_external_group_msg(session, chat_id, content, retry+1)

async def batch_send(chat_ids: list, content: str):
    """批量發送（控制并發數）"""
    # 創建異步session（復用連接）
    async with aiohttp.ClientSession() as session:
        # 限制并發數
        semaphore = asyncio.Semaphore(CONCURRENCY)
        tasks = []
        for chat_id in chat_ids:
            # 用信號量控制并發
            task = asyncio.create_task(
                send_with_semaphore(semaphore, session, chat_id, content)
            )
            tasks.append(task)
        # 等待所有任務完成
        await asyncio.gather(*tasks)

async def send_with_semaphore(sem, session, chat_id, content):
    """帶信號量的發送函數"""
    async with sem:
        await send_external_group_msg(session, chat_id, content)

if __name__ == "__main__":
    # 示例：發送給多個外部群
    chat_ids = ["chat123456", "chat789012"]
    content = "【溫馨提示】本周服務升級，如有問題請聯系客服"
    # 運行異步任務
    asyncio.run(batch_send(chat_ids, content))