api.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strings"
	"time"
)

type apiClient struct {
	base  string
	token string
	http  *http.Client
}

func newAPIClient(base, token string) *apiClient {
	return &apiClient{
		base:  strings.TrimRight(base, "/"),
		token: token,
		http:  &http.Client{Timeout: 30 * time.Second},
	}
}

type signupIntentResp struct {
	IntentID  string `json:"intent_id"`
	SignupURL string `json:"signup_url"`
	ExpiresAt string `json:"expires_at"`
}

type signupIntentPollResp struct {
	Status   string `json:"status"`
	APIToken string `json:"api_token,omitempty"`
}

type shareResp struct {
	UUID                 string   `json:"uuid"`
	ShortID              string   `json:"short_id"`
	Filename             string   `json:"filename"`
	Path                 string   `json:"path,omitempty"`
	Watch                bool     `json:"watch"`
	URL                  string   `json:"url"`
	CommentAccess        string   `json:"comment_access"`
	DocVisibility        string   `json:"doc_visibility"`
	CreatedAt            string   `json:"created_at"`
	UpdatedAt            string   `json:"updated_at"`
	SizeBytes            int      `json:"size_bytes"`
	UnresolvedCount      int      `json:"unresolved_count"`
	AgentUnresolvedCount int      `json:"agent_unresolved_count"`
	Labels               []string `json:"labels"`
}

// shareOpts are POST /api/shares policy fields. Empty strings are omitted so
// an upsert does not clobber stored values (server omitted = no-touch).
type shareOpts struct {
	CommentAccess string
	DocVisibility string
	Labels        *[]string
}

type commentView struct {
	UUID       string `json:"uuid"`
	AuthorKind string `json:"author_kind"`
	AuthorName string `json:"author_name"`
	Body       string `json:"body"`
	CreatedAt  string `json:"created_at"`
}

type commentTarget struct {
	Path    string `json:"path"`
	Text    string `json:"text"`
	MDStart int    `json:"md_start"`
	MDEnd   int    `json:"md_end"`
}

type threadView struct {
	UUID           string         `json:"uuid"`
	Anchor         string         `json:"anchor"`
	CurrentAnchor  string         `json:"current_anchor"`
	AnchorType     string         `json:"anchor_type"`
	Quote          string         `json:"quote"`
	QuoteIndex     int            `json:"quote_index"`
	QuoteStart     int            `json:"quote_start"`
	QuoteEnd       int            `json:"quote_end"`
	MDStart        int            `json:"md_start"`
	MDEnd          int            `json:"md_end"`
	QueuePosition  int            `json:"queue_position"`
	QueueLength    int            `json:"queue_length"`
	Orphaned       bool           `json:"orphaned"`
	Resolved       bool           `json:"resolved"`
	CreatedVersion int            `json:"created_version"`
	Comments       []commentView  `json:"comments"`
	Target         *commentTarget `json:"target,omitempty"`
}

type threadsResp struct {
	Threads []threadView `json:"threads"`
}

func (c *apiClient) do(method, path string, body, dst any) error {
	status, err := c.doStatus(method, path, body, dst)
	if err != nil {
		return err
	}
	_ = status
	return nil
}

func (c *apiClient) doStatus(method, path string, body, dst any) (int, error) {
	var rdr io.Reader
	if body != nil {
		buf, err := json.Marshal(body)
		if err != nil {
			return 0, fmt.Errorf("marshal: %w", err)
		}
		rdr = bytes.NewReader(buf)
	}
	req, err := http.NewRequest(method, c.base+path, rdr)
	if err != nil {
		return 0, err
	}
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	if c.token != "" {
		req.Header.Set("Authorization", "Bearer "+c.token)
	}
	resp, err := c.http.Do(req)
	if err != nil {
		return 0, fmt.Errorf("request: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
		return resp.StatusCode, fmt.Errorf("HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(raw)))
	}
	if dst == nil {
		_, _ = io.Copy(io.Discard, resp.Body)
		return resp.StatusCode, nil
	}
	if err := json.NewDecoder(resp.Body).Decode(dst); err != nil {
		return resp.StatusCode, fmt.Errorf("decode: %w", err)
	}
	return resp.StatusCode, nil
}

func (c *apiClient) Signup(email string) (*signupIntentResp, error) {
	var out signupIntentResp
	if err := c.do("POST", "/api/signup/intent", map[string]string{"email": email}, &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (c *apiClient) PollSignupIntent(id string) (*signupIntentPollResp, error) {
	var out signupIntentPollResp
	if err := c.do("GET", "/api/signup/intent/"+id, nil, &out); err != nil {
		return nil, err
	}
	return &out, nil
}

type manageIntentResp struct {
	IntentID     string `json:"intent_id"`
	DashboardURL string `json:"dashboard_url"`
	ExpiresAt    string `json:"expires_at"`
}

func (c *apiClient) OpenManageIntent() (*manageIntentResp, error) {
	var out manageIntentResp
	if err := c.do("POST", "/api/manage/intent", nil, &out); err != nil {
		return nil, err
	}
	return &out, nil
}

type inviteResp struct {
	InviteURL string `json:"invite_url"`
	ExpiresAt string `json:"expires_at"`
	Email     string `json:"email,omitempty"`
	ShortID   string `json:"short_id,omitempty"`
}

func (c *apiClient) CreateInvite(email, shortID string) (*inviteResp, error) {
	var body any
	if email != "" || shortID != "" {
		m := map[string]string{}
		if email != "" {
			m["email"] = email
		}
		if shortID != "" {
			m["short_id"] = shortID
		}
		body = m
	}
	var out inviteResp
	status, err := c.doStatus("POST", "/api/invites", body, &out)
	if err != nil {
		return nil, mapInviteAPIError(status, err)
	}
	return &out, nil
}

func (c *apiClient) CreateShare(filename, path, content string, watch bool, opts shareOpts) (*shareResp, bool, error) {
	var out shareResp
	body := map[string]any{
		"filename": filename,
		"path":     path,
		"content":  content,
		"watch":    watch,
	}
	if opts.CommentAccess != "" {
		body["comment_access"] = opts.CommentAccess
	}
	if opts.DocVisibility != "" {
		body["doc_visibility"] = opts.DocVisibility
	}
	if opts.Labels != nil {
		body["labels"] = *opts.Labels
	}
	status, err := c.doStatus("POST", "/api/shares", body, &out)
	if err != nil {
		return nil, false, err
	}
	return &out, status == http.StatusCreated, nil
}

func (c *apiClient) UpdateShare(uuid, content string) (*shareResp, error) {
	var out shareResp
	if err := c.do("PUT", fmt.Sprintf("/api/shares/%s", uuid), map[string]string{"content": content}, &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (c *apiClient) DeleteShare(uuid string) error {
	return c.do("DELETE", fmt.Sprintf("/api/shares/%s", uuid), nil, nil)
}

func (c *apiClient) ValidateToken() error {
	return c.do("GET", "/api/shares", nil, nil)
}

func (c *apiClient) ListShares() ([]shareResp, error) {
	var out []shareResp
	if err := c.do("GET", "/api/shares", nil, &out); err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiClient) ListSharesIfNoneMatch(etag string) (shares []shareResp, newETag string, notModified bool, err error) {
	req, err := http.NewRequest(http.MethodGet, c.base+"/api/shares", nil)
	if err != nil {
		return nil, "", false, err
	}
	if c.token != "" {
		req.Header.Set("Authorization", "Bearer "+c.token)
	}
	if etag != "" {
		req.Header.Set("If-None-Match", etag)
	}
	resp, err := c.http.Do(req)
	if err != nil {
		return nil, "", false, fmt.Errorf("request: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusNotModified {
		_, _ = io.Copy(io.Discard, resp.Body)
		return nil, etag, true, nil
	}
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		raw, _ := io.ReadAll(io.LimitReader(resp.Body, 4096))
		return nil, "", false, fmt.Errorf("HTTP %d: %s", resp.StatusCode, strings.TrimSpace(string(raw)))
	}
	if err := json.NewDecoder(resp.Body).Decode(&shares); err != nil {
		return nil, "", false, fmt.Errorf("decode: %w", err)
	}
	if shares == nil {
		shares = []shareResp{}
	}
	return shares, resp.Header.Get("ETag"), false, nil
}

func (c *apiClient) ListSharesByFilename(filename string) ([]shareResp, error) {
	var out []shareResp
	path := "/api/shares?filename=" + url.QueryEscape(filename)
	if err := c.do("GET", path, nil, &out); err != nil {
		return nil, err
	}
	return out, nil
}

func (c *apiClient) ListComments(shareUUID string, unresolved, forAgent bool) ([]threadView, error) {
	path := fmt.Sprintf("/api/shares/%s/comments", shareUUID)
	q := url.Values{}
	if unresolved {
		q.Set("unresolved", "1")
	}
	if forAgent {
		q.Set("for_agent", "1")
	}
	if enc := q.Encode(); enc != "" {
		path += "?" + enc
	}
	var out threadsResp
	if err := c.do("GET", path, nil, &out); err != nil {
		return nil, err
	}
	return out.Threads, nil
}

func (c *apiClient) ReplyComment(shareUUID, threadUUID, body string) (*threadView, error) {
	var out threadView
	path := fmt.Sprintf("/api/shares/%s/comments/%s/replies", shareUUID, threadUUID)
	if err := c.do("POST", path, map[string]string{"body": body}, &out); err != nil {
		return nil, err
	}
	return &out, nil
}

func (c *apiClient) ResolveThread(shareUUID, threadUUID string) error {
	return c.do("POST", fmt.Sprintf("/api/shares/%s/comments/%s/resolve", shareUUID, threadUUID), nil, nil)
}

func (c *apiClient) UnresolveThread(shareUUID, threadUUID string) error {
	return c.do("POST", fmt.Sprintf("/api/shares/%s/comments/%s/unresolve", shareUUID, threadUUID), nil, nil)
}

func (c *apiClient) GetShareByShortID(shortID string) (*shareResp, error) {
	all, err := c.ListShares()
	if err != nil {
		return nil, err
	}
	for i := range all {
		if all[i].ShortID == shortID {
			return &all[i], nil
		}
	}
	return nil, fmt.Errorf("share %s not found in your account", shortID)
}