client.go

// Copyright 2026 Columnar Technologies Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package dbc

import (
	"fmt"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"runtime"
	"sync"

	"github.com/columnar-tech/dbc/auth"
	"github.com/columnar-tech/dbc/internal"
	"github.com/google/uuid"
)

type clientConfig struct {
	httpClient *http.Client
	// registries holds the current registry list as options are applied.
	// WithRegistries overwrites this; WithGlobalConfig/WithProjectRegistries
	// consult it as the "defaults" slice in the merge, which means callers
	// who pass WithRegistries retain full control over that baseline.
	registries             []Registry
	userAgent              string
	baseURL                string
	credentialResolver     func(*url.URL) (*auth.Credential, error)
	globalConfig           *GlobalConfig
	projectRegistries      []RegistryEntry
	projectReplaceDefaults *bool
	// explicitRegistries tracks whether the caller passed WithRegistries.
	// When true, registry-config options (global/project) are ignored so
	// the caller's explicit registry set is used as-is.
	explicitRegistries bool
}

type Option func(*clientConfig)

// Client is a dbc client for searching registries and managing ADBC drivers.
type Client struct {
	httpClient         *http.Client
	registries         []Registry
	userAgent          string
	mid                string
	uid                uuid.UUID
	setupOnce          sync.Once
	credentialResolver func(*url.URL) (*auth.Credential, error)
}

// NewClient creates a new driver registry client with the given options.
func NewClient(opts ...Option) (*Client, error) {
	cfg := &clientConfig{
		registries: []Registry{
			{BaseURL: mustParseURL("https://dbc-cdn.columnar.tech")},
			{BaseURL: mustParseURL("https://" + auth.DefaultOauthURI())},
		},
		userAgent: fmt.Sprintf("dbc-cli/%s (%s; %s)", Version, runtime.GOOS, runtime.GOARCH),
	}

	for _, opt := range opts {
		opt(cfg)
	}

	httpClient := cfg.httpClient
	if httpClient == nil {
		httpClient = &http.Client{
			Transport: &uaRoundTripper{
				RoundTripper: http.DefaultTransport,
				userAgent:    cfg.userAgent,
			},
		}
	}

	if cfg.baseURL != "" {
		cfg.registries = []Registry{{BaseURL: mustParseURL(cfg.baseURL)}}
	} else if cfg.explicitRegistries {
		// WithRegistries was passed — use the caller's list verbatim and
		// do not merge with global/project configuration.
	} else if cfg.globalConfig != nil || cfg.projectRegistries != nil || cfg.projectReplaceDefaults != nil {
		for _, e := range cfg.projectRegistries {
			if err := validateRegistryEntry(e); err != nil {
				return nil, err
			}
		}
		var globalRegs []RegistryEntry
		var globalReplace bool
		if cfg.globalConfig != nil {
			for _, e := range cfg.globalConfig.Registries {
				if err := validateRegistryEntry(e); err != nil {
					return nil, err
				}
			}
			globalRegs = cfg.globalConfig.Registries
			globalReplace = cfg.globalConfig.ReplaceDefaults
		}
		merged := mergeRegistries(cfg.projectRegistries, cfg.projectReplaceDefaults, globalRegs, globalReplace, cfg.registries)
		if len(merged) == 0 {
			return nil, fmt.Errorf("registry configuration produced an empty registry list; replace_defaults requires at least one [[registries]] entry")
		}
		cfg.registries = merged
	}

	credResolver := cfg.credentialResolver
	if credResolver == nil {
		credResolver = auth.GetCredentials
	}

	return &Client{
		httpClient:         httpClient,
		registries:         cfg.registries,
		userAgent:          cfg.userAgent,
		credentialResolver: credResolver,
	}, nil
}

func (c *Client) setup() {
	c.setupOnce.Do(func() {
		c.mid, _ = telemetryMachineID()

		userdir, err := internal.GetUserConfigPath()
		if err != nil {
			c.uid = uuid.New()
			return
		}

		fp := filepath.Join(userdir, "uid.uuid")
		data, err := os.ReadFile(fp)
		if err == nil {
			if err = c.uid.UnmarshalBinary(data); err == nil {
				return
			}
		}

		c.uid = uuid.New()
		if err = os.MkdirAll(filepath.Dir(fp), 0o700); err == nil {
			if data, err = c.uid.MarshalBinary(); err == nil {
				os.WriteFile(fp, data, 0o600)
			}
		}
	})
}

func (c *Client) HTTPClient() *http.Client { return c.httpClient }

// Registries returns the list of driver registries configured for this client.
func (c *Client) Registries() []Registry { return c.registries }

// UserAgent returns the user agent string used by this client.
func (c *Client) UserAgent() string { return c.userAgent }

// WithHTTPClient sets the HTTP client to use for requests.
func WithHTTPClient(hc *http.Client) Option {
	return func(cfg *clientConfig) { cfg.httpClient = hc }
}

// WithCredentialResolver sets the resolver used to look up credentials for a
// registry URL, overriding the default on-disk resolver. Useful where there is
// no credential file (e.g. WASM hosts injecting a token).
func WithCredentialResolver(resolver func(*url.URL) (*auth.Credential, error)) Option {
	return func(cfg *clientConfig) { cfg.credentialResolver = resolver }
}

// WithRegistries sets the driver registries to use. When passed, this takes
// precedence over any WithGlobalConfig / WithProjectRegistries options: the
// caller's explicit list is used as-is, not merged with configuration files.
func WithRegistries(r []Registry) Option {
	return func(cfg *clientConfig) {
		cfg.registries = append([]Registry(nil), r...)
		cfg.explicitRegistries = true
	}
}

// WithBaseURL sets the base URL for the driver registry.
func WithBaseURL(u string) Option {
	return func(cfg *clientConfig) { cfg.baseURL = u }
}

// WithUserAgent sets the user agent string for requests. This only takes
// effect when no custom HTTP client is provided via WithHTTPClient; if a
// custom client is supplied its transport is used as-is.
func WithUserAgent(ua string) Option {
	return func(cfg *clientConfig) { cfg.userAgent = ua }
}