package adapter

import (
	"bytes"
	"context"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"time"
)

type dingtalkConfig struct {
	WebhookURL string `json:"webhook_url"`
	Secret     string `json:"secret,omitempty"`
}

type dingtalkMessage struct {
	MsgType  string      `json:"msgtype"`
	Markdown *dingtalkMD `json:"markdown"`
}

type dingtalkMD struct {
	Title string `json:"title"`
	Text  string `json:"text"`
}

type DingTalkSender struct {
	limiter *DingTalkLimiter
}

func (s *DingTalkSender) Type() string { return "dingtalk" }

func (s *DingTalkSender) Send(title, content string, config json.RawMessage) error {
	var cfg dingtalkConfig
	if err := json.Unmarshal(config, &cfg); err != nil {
		return fmt.Errorf("parse dingtalk config: %w", err)
	}

	if s.limiter != nil {
		if err := s.limiter.Acquire(context.Background(), DingTalkLimitKey(cfg.WebhookURL)); err != nil {
			return fmt.Errorf("dingtalk rate limit: %w", err)
		}
	}

	reqURL := cfg.WebhookURL
	if cfg.Secret != "" {
		timestamp := time.Now().UnixMilli()
		sign := dingtalkSign(timestamp, cfg.Secret)
		reqURL = fmt.Sprintf("%s&timestamp=%d&sign=%s", cfg.WebhookURL, timestamp, sign)
	}

	msg := dingtalkMessage{
		MsgType: "markdown",
		Markdown: &dingtalkMD{
			Title: title,
			Text:  content,
		},
	}

	body, _ := json.Marshal(msg)
	resp, err := http.Post(reqURL, "application/json", bytes.NewReader(body))
	if err != nil {
		return fmt.Errorf("dingtalk send: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode >= 400 {
		return fmt.Errorf("dingtalk returned status %d", resp.StatusCode)
	}
	return nil
}

func dingtalkSign(timestamp int64, secret string) string {
	mac := hmac.New(sha256.New, []byte(secret))
	fmt.Fprintf(mac, "%d\n%s", timestamp, secret)
	signData := mac.Sum(nil)
	return url.QueryEscape(base64.StdEncoding.EncodeToString(signData))
}