client.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"mime"
	"mime/multipart"
	"net/http"
	"net/textproto"
	"net/url"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"
)

// Client handles API requests
type Client struct {
	baseURL     string
	accessToken string
	httpClient  *http.Client
}

// NewClient creates a new API client
func NewClient(baseURL, accessToken string) *Client {
	return &Client{
		baseURL:     strings.TrimSuffix(baseURL, "/"),
		accessToken: accessToken,
		httpClient:  &http.Client{Timeout: 30 * time.Second},
	}
}

// request makes an HTTP request to the API
func (c *Client) request(method, path string, params map[string]interface{}, body interface{}) (map[string]interface{}, error) {
	urlStr := c.baseURL + path

	// Add query parameters
	if len(params) > 0 && (method == "GET" || method == "DELETE") {
		u, _ := url.Parse(urlStr)
		q := u.Query()
		for k, v := range params {
			if v == nil {
				continue
			}
			switch val := v.(type) {
			case string:
				if val != "" {
					q.Set(k, val)
				}
			case []string:
				for _, s := range val {
					q.Add(k, s)
				}
			case int:
				q.Set(k, strconv.Itoa(val))
			case bool:
				q.Set(k, strconv.FormatBool(val))
			default:
				q.Set(k, fmt.Sprintf("%v", val))
			}
		}
		u.RawQuery = q.Encode()
		urlStr = u.String()
	}

	var reqBody io.Reader
	if body != nil {
		jsonData, err := json.Marshal(body)
		if err != nil {
			return nil, fmt.Errorf("failed to marshal request body: %w", err)
		}
		reqBody = bytes.NewBuffer(jsonData)
	}

	req, err := http.NewRequest(method, urlStr, reqBody)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	req.Header.Set("Authorization", "Bearer "+c.accessToken)
	if body != nil {
		req.Header.Set("Content-Type", "application/json")
	}

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

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

	if resp.StatusCode >= 400 {
		var errResp map[string]interface{}
		if json.Unmarshal(respBody, &errResp) == nil {
			if errMsg, ok := errResp["error"].(string); ok {
				return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, errMsg)
			}
		}
		return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, string(respBody))
	}

	if len(respBody) == 0 || resp.StatusCode == 204 {
		return map[string]interface{}{"success": true}, nil
	}

	// Try parsing as object first, then as array
	var result map[string]interface{}
	if err := json.Unmarshal(respBody, &result); err != nil {
		// Try parsing as array
		var arrayResult []interface{}
		if err := json.Unmarshal(respBody, &arrayResult); err != nil {
			return nil, fmt.Errorf("failed to parse response: %w", err)
		}
		// Wrap array in a map for consistent handling
		return map[string]interface{}{"items": arrayResult}, nil
	}

	return result, nil
}

// uploadFile uploads a file using multipart form with correct mime type
func (c *Client) uploadFile(path, filePath string) (map[string]interface{}, error) {
	file, err := os.Open(filePath)
	if err != nil {
		return nil, fmt.Errorf("failed to open file: %w", err)
	}
	defer file.Close()

	// Detect mime type from extension
	filename := filepath.Base(filePath)
	ext := filepath.Ext(filePath)
	mimeType := mime.TypeByExtension(ext)
	if mimeType == "" {
		mimeType = "application/octet-stream"
	}

	body := &bytes.Buffer{}
	writer := multipart.NewWriter(body)

	// Create form file with correct Content-Type
	h := make(textproto.MIMEHeader)
	h.Set("Content-Disposition", fmt.Sprintf(`form-data; name="file"; filename="%s"`, filename))
	h.Set("Content-Type", mimeType)

	part, err := writer.CreatePart(h)
	if err != nil {
		return nil, fmt.Errorf("failed to create form file: %w", err)
	}

	if _, err := io.Copy(part, file); err != nil {
		return nil, fmt.Errorf("failed to copy file: %w", err)
	}
	writer.Close()

	req, err := http.NewRequest("POST", c.baseURL+path, body)
	if err != nil {
		return nil, fmt.Errorf("failed to create request: %w", err)
	}

	req.Header.Set("Authorization", "Bearer "+c.accessToken)
	req.Header.Set("Content-Type", writer.FormDataContentType())

	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, fmt.Errorf("request failed: %w", err)
	}
	defer resp.Body.Close()

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

	if resp.StatusCode >= 400 {
		return nil, fmt.Errorf("API error (%d): %s", resp.StatusCode, string(respBody))
	}

	var result map[string]interface{}
	if err := json.Unmarshal(respBody, &result); err != nil {
		return nil, fmt.Errorf("failed to parse response: %w", err)
	}

	return result, nil
}

func getClient() (*Client, error) {
	token := accessToken
	if token == "" {
		token = os.Getenv("BEEPER_ACCESS_TOKEN")
	}
	if token == "" {
		return nil, fmt.Errorf("access token required. Set BEEPER_ACCESS_TOKEN or use --token")
	}

	url := baseURL
	if url == "" {
		url = os.Getenv("BEEPER_DESKTOP_BASE_URL")
	}
	if url == "" {
		url = defaultBaseURL
	}

	return NewClient(url, token), nil
}