github.go

package channels

import (
	"bytes"
	"context"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"log/slog"
	"net/http"
	"strconv"
	"strings"
	"sync"
	"time"

	"nuclaw/internal/config"
)

// GitHubAdapter handles GitHub issues and notifications.
type GitHubAdapter struct {
	*BaseAdapter
	cfg         *config.Config
	owner       string
	repo        string
	token       string
	client      *http.Client
	polling     bool
	stopCh      chan struct{}
	wg          sync.WaitGroup
	stopMu         sync.Mutex
	webhookSecret  string
	lastIssueUpdate time.Time
	lastPRUpdate    time.Time
	logger         *slog.Logger
}

// GHPullRequestRef represents a reference to a PR within an issue.
type GHPullRequestRef struct {
	URL     string `json:"url"`
	HTMLURL string `json:"html_url"`
}

// GHIssue represents a GitHub issue.
type GHIssue struct {
	ID          int               `json:"id"`
	Number      int               `json:"number"`
	Title       string            `json:"title"`
	State       string            `json:"state"`
	User        GHUser            `json:"user"`
	Body        string            `json:"body"`
	HTMLURL     string            `json:"html_url"`
	PullRequest *GHPullRequestRef `json:"pull_request"`
	CreatedAt   time.Time         `json:"created_at"`
	UpdatedAt   time.Time         `json:"updated_at"`
}

// GHUser represents a GitHub user.
type GHUser struct {
	Login string `json:"login"`
	ID    int    `json:"id"`
}

// GHPullRequest represents a GitHub pull request.
type GHPullRequest struct {
	ID        int        `json:"id"`
	Number    int        `json:"number"`
	Title     string     `json:"title"`
	State     string     `json:"state"`
	User      GHUser     `json:"user"`
	Body      string     `json:"body"`
	HTMLURL   string     `json:"html_url"`
	IsDraft   bool       `json:"draft"`
	MergedAt  *time.Time `json:"merged_at"`
	CreatedAt time.Time  `json:"created_at"`
	UpdatedAt time.Time  `json:"updated_at"`
}

// GHComment represents a GitHub issue/PR comment.
type GHComment struct {
	ID        int       `json:"id"`
	Body      string    `json:"body"`
	User      GHUser    `json:"user"`
	CreatedAt time.Time `json:"created_at"`
	UpdatedAt time.Time `json:"updated_at"`
}

// GHIssueCommentEvent represents a webhook event payload.
type GHIssueCommentEvent struct {
	Action  string    `json:"action"`
	Issue   GHIssue   `json:"issue"`
	Comment GHComment `json:"comment"`
	Repo    GHRepo    `json:"repository"`
}

// GHRepo represents a GitHub repository.
type GHRepo struct {
	Name  string `json:"name"`
	Owner GHUser `json:"owner"`
}

// NewGitHubAdapter creates a new GitHub adapter.
func NewGitHubAdapter(cfg *config.Config) (*GitHubAdapter, error) {
	if cfg.GitHubOwner == "" || cfg.GitHubRepo == "" {
		return nil, fmt.Errorf("GITHUB_OWNER and GITHUB_REPO are required")
	}

	return &GitHubAdapter{
		BaseAdapter:    NewBaseAdapter("github"),
		cfg:            cfg,
		owner:          cfg.GitHubOwner,
		repo:           cfg.GitHubRepo,
		token:          cfg.GitHubToken,
		webhookSecret:  cfg.GitHubWebhookSecret,
		client:         &http.Client{Timeout: 30 * time.Second},
		stopCh:         make(chan struct{}),
		logger:         slog.Default().With("channel", "github", "repo", cfg.GitHubOwner+"/"+cfg.GitHubRepo),
	}, nil
}

// githubURL builds the API URL for the repository.
func (g *GitHubAdapter) githubURL(path string) string {
	return "https://api.github.com" + path
}

// githubRequest creates an authenticated GitHub API request.
func (g *GitHubAdapter) githubRequest(ctx context.Context, method, url string, body []byte) (*http.Request, error) {
	var bodyReader *bytes.Reader
	if body != nil {
		bodyReader = bytes.NewReader(body)
	} else {
		bodyReader = bytes.NewReader([]byte{})
	}

	req, err := http.NewRequestWithContext(ctx, method, url, bodyReader)
	if err != nil {
		return nil, fmt.Errorf("creating request: %w", err)
	}

	req.Header.Set("Authorization", "Bearer "+g.token)
	req.Header.Set("Accept", "application/vnd.github.v3+json")
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("X-GitHub-Api-Version", "2022-11-28")

	return req, nil
}

// do executes a GitHub API request and returns the parsed response.
func (g *GitHubAdapter) do(ctx context.Context, method, path string, body []byte, result interface{}) error {
	url := g.githubURL(path)
	req, err := g.githubRequest(ctx, method, url, body)
	if err != nil {
		return err
	}

	resp, err := retryWithBackoff(ctx, defaultMaxRetries, defaultInitialBackoff, func() (*http.Response, error) {
		return g.client.Do(req)
	})
	if err != nil {
		return fmt.Errorf("request failed: %w", err)
	}
	defer func() { _ = resp.Body.Close() }()

	// Check rate limit and log warning if running low
	if rl := parseRateLimit(resp); rl.Remaining >= 0 && rl.Remaining <= 10 {
		g.logger.Warn("GitHub rate limit low", "remaining", rl.Remaining, "limit", rl.Limit, "reset", rl.Reset)
	}

	respBody, err := io.ReadAll(resp.Body)
	if err != nil {
		return fmt.Errorf("reading response: %w", err)
	}

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return fmt.Errorf("GitHub API error (%d): %s", resp.StatusCode, string(respBody))
	}

	if result == nil {
		return nil
	}

	if err := json.Unmarshal(respBody, result); err != nil {
		return fmt.Errorf("unmarshaling response: %w", err)
	}

	return nil
}

// FetchMessages fetches new and updated issues and PRs from the repository.
func (g *GitHubAdapter) FetchMessages(ctx context.Context) ([]*Message, error) {
	var issues []GHIssue
	path := fmt.Sprintf("/repos/%s/%s/issues?state=all&per_page=30&sort=updated&direction=desc", g.owner, g.repo)
	if err := g.do(ctx, "GET", path, nil, &issues); err != nil {
		return nil, fmt.Errorf("fetching issues: %w", err)
	}

	prevIssueUpdate := g.lastIssueUpdate
	var msgs []*Message
	for _, issue := range issues {
		// Deduplicate: compare against the timestamp from the *previous* poll,
		// not the running max within this batch (which would skip all but the first).
		if !issue.UpdatedAt.After(prevIssueUpdate) {
			continue
		}
		// Track the newest timestamp seen in this batch for the next poll cycle.
		if issue.UpdatedAt.After(g.lastIssueUpdate) {
			g.lastIssueUpdate = issue.UpdatedAt
		}

		// Skip PRs - they'll be fetched separately
		if issue.PullRequest != nil {
			continue
		}

		msg := &Message{
			ID:          fmt.Sprintf("issue/%d", issue.ID),
			ChannelType: "github",
			PlatformID:  fmt.Sprintf("%s/%s", g.owner, g.repo),
			SenderID:    strconv.Itoa(issue.User.ID),
			SenderName:  issue.User.Login,
			Content:     fmt.Sprintf("#%d: %s\n\n%s", issue.Number, issue.Title, issue.Body),
			Timestamp:   issue.UpdatedAt,
			ThreadID:    strconv.Itoa(issue.Number),
			Raw:         issue,
		}
		msgs = append(msgs, msg)
	}

	// Fetch PRs separately
	var prs []GHPullRequest
	prPath := fmt.Sprintf("/repos/%s/%s/pulls?state=all&per_page=30&sort=updated&direction=desc", g.owner, g.repo)
	if err := g.do(ctx, "GET", prPath, nil, &prs); err != nil {
		g.logger.Warn("fetching PRs failed", "error", err)
	} else {
		prevPRUpdate := g.lastPRUpdate
		for _, pr := range prs {
			if !pr.UpdatedAt.After(prevPRUpdate) {
				continue
			}
			if pr.UpdatedAt.After(g.lastPRUpdate) {
				g.lastPRUpdate = pr.UpdatedAt
			}

			state := pr.State
			if pr.State == "closed" && pr.MergedAt != nil {
				state = "merged"
			}

			msg := &Message{
				ID:          fmt.Sprintf("pr/%d", pr.ID),
				ChannelType: "github",
				PlatformID:  fmt.Sprintf("%s/%s", g.owner, g.repo),
				SenderID:    strconv.Itoa(pr.User.ID),
				SenderName:  pr.User.Login,
				Content:     fmt.Sprintf("PR #%d: %s (%s)\n\n%s", pr.Number, pr.Title, state, pr.Body),
				Timestamp:   pr.UpdatedAt,
				ThreadID:    strconv.Itoa(pr.Number),
				Raw:         pr,
			}
			msgs = append(msgs, msg)
		}
	}

	return msgs, nil
}

// SendMessage sends a message via GitHub.
// platformID can be:
//   - Issue number: "123" -> adds comment to issue #123
//   - PR number: "pr/123" -> adds comment to PR #123
//   - "new" -> creates a new issue
func (g *GitHubAdapter) SendMessage(ctx context.Context, platformID string, msg *OutgoingMessage) error {
	if platformID == "" {
		return fmt.Errorf("platformID (issue/PR number) is required")
	}

	// Check if creating new issue
	if platformID == "new" {
		return g.createIssue(ctx, msg)
	}

	// Parse the target (issue or PR number)
	targetNum := platformID
	isPR := false
	if strings.HasPrefix(strings.ToLower(platformID), "pr/") {
		targetNum = strings.TrimPrefix(platformID, "pr/")
		isPR = true
	}

	num, err := strconv.Atoi(targetNum)
	if err != nil {
		return fmt.Errorf("invalid issue/PR number: %w", err)
	}

	return g.addComment(ctx, num, isPR, msg.Content)
}

// createIssue creates a new issue.
func (g *GitHubAdapter) createIssue(ctx context.Context, msg *OutgoingMessage) error {
	type IssueRequest struct {
		Title string `json:"title"`
		Body  string `json:"body"`
	}

	parts := strings.SplitN(msg.Content, "\n", 2)
	title := strings.TrimRight(parts[0], "\r")
	body := ""
	if len(parts) > 1 {
		body = parts[1]
	}

	// Extract title from ThreadID if provided
	if msg.ThreadID != "" {
		threadNum, err := strconv.Atoi(msg.ThreadID)
		if err == nil {
			title = fmt.Sprintf("Issue #%d", threadNum)
		}
	}

	reqBody, err := json.Marshal(IssueRequest{
		Title: title,
		Body:  body,
	})
	if err != nil {
		return fmt.Errorf("marshaling request: %w", err)
	}

	path := fmt.Sprintf("/repos/%s/%s/issues", g.owner, g.repo)
	if err := g.do(ctx, "POST", path, reqBody, nil); err != nil {
		return fmt.Errorf("creating issue: %w", err)
	}

	return nil
}

// addComment adds a comment to an issue or PR.
// Both issue and PR comments use the /issues/{number}/comments endpoint
// (GitHub treats PRs as issues). The isPR parameter is retained for callers
// that need to distinguish the target type in logs or future behavior.
func (g *GitHubAdapter) addComment(ctx context.Context, num int, isPR bool, content string) error {
	type CommentRequest struct {
		Body string `json:"body"`
	}

	reqBody, err := json.Marshal(CommentRequest{Body: content})
	if err != nil {
		return fmt.Errorf("marshaling request: %w", err)
	}

	// Both issues and PRs use the same comments endpoint.
	// The /pulls/{num}/comments endpoint is for review comments on specific diffs.
	path := fmt.Sprintf("/repos/%s/%s/issues/%d/comments", g.owner, g.repo, num)

	if err := g.do(ctx, "POST", path, reqBody, nil); err != nil {
		return fmt.Errorf("adding comment: %w", err)
	}

	return nil
}

// StartPolling starts the polling loop.
func (g *GitHubAdapter) StartPolling(ctx context.Context, handler func(*Message) error, interval time.Duration) error {
	g.stopMu.Lock()
	defer g.stopMu.Unlock()

	if g.polling {
		return fmt.Errorf("already polling")
	}

	g.polling = true
	g.stopCh = make(chan struct{})

	g.wg.Add(1)
	go func() {
		defer g.wg.Done()
		ticker := time.NewTicker(interval)
		defer ticker.Stop()

		for {
			select {
			case <-ctx.Done():
				return
			case <-g.stopCh:
				return
			case <-ticker.C:
				msgs, err := g.FetchMessages(ctx)
				if err != nil {
					g.logger.Error("fetch error", "error", err)
					continue
				}
				for _, msg := range msgs {
					if err := handler(msg); err != nil {
						g.logger.Error("handler error", "error", err)
					}
				}
			}
		}
	}()

	return nil
}

// StopPolling stops the polling loop.
func (g *GitHubAdapter) StopPolling() error {
	g.stopMu.Lock()
	defer g.stopMu.Unlock()

	if !g.polling {
		return nil
	}

	g.polling = false
	close(g.stopCh)
	g.wg.Wait()
	// stopCh is left closed — StartPolling creates a fresh one.

	return nil
}

// HandleWebhook processes a GitHub webhook event.
// The payload should be the raw request body, and signature should be the X-Hub-Signature-256 header.
func (g *GitHubAdapter) HandleWebhook(payload []byte, signature string) (*Message, error) {
	if g.webhookSecret != "" {
		if err := g.verifySignature(payload, signature); err != nil {
			return nil, fmt.Errorf("webhook signature verification failed: %w", err)
		}
	}

	var event GHIssueCommentEvent
	if err := json.Unmarshal(payload, &event); err != nil {
		return nil, fmt.Errorf("parsing webhook: %w", err)
	}

	msg := &Message{
		ID:          fmt.Sprintf("comment/%d", event.Comment.ID),
		ChannelType: "github",
		PlatformID:  fmt.Sprintf("%s/%s", g.owner, g.repo),
		SenderID:   strconv.Itoa(event.Comment.User.ID),
		SenderName:  event.Comment.User.Login,
		Content:    event.Comment.Body,
		Timestamp:  event.Comment.CreatedAt,
		ThreadID:   strconv.Itoa(event.Issue.Number),
		Raw:       event,
	}

	return msg, nil
}

// verifySignature validates the X-Hub-Signature-256 HMAC hex digest.
func (g *GitHubAdapter) verifySignature(payload []byte, signatureHeader string) error {
	const prefix = "sha256="
	if !strings.HasPrefix(signatureHeader, prefix) {
		return fmt.Errorf("signature missing sha256= prefix")
	}
	sigHex := strings.TrimPrefix(signatureHeader, prefix)
	sig, err := hex.DecodeString(sigHex)
	if err != nil {
		return fmt.Errorf("decoding signature hex: %w", err)
	}

	mac := hmac.New(sha256.New, []byte(g.webhookSecret))
	mac.Write(payload)
	expected := mac.Sum(nil)

	if !hmac.Equal(sig, expected) {
		return fmt.Errorf("signature mismatch")
	}
	return nil
}

// Ensure GitHubAdapter implements Adapter
var _ Adapter = (*GitHubAdapter)(nil)