provider_import.go

package main

import (
	"encoding/base64"
	"encoding/json"
	"errors"
	"net/url"
	"os"
	"path/filepath"
	"strings"
)

func pendingProviderImportPath() string {
	return filepath.Join(stateDir(), "pending-provider-import.json")
}

func providerImportRequestFromURL(rawURL string) (providerImportRequest, error) {
	parsed, err := url.Parse(strings.TrimSpace(rawURL))
	if err != nil {
		return providerImportRequest{}, err
	}
	values := parsed.Query()
	decodeBlob := func(key string) (string, error) {
		value := strings.TrimSpace(values.Get(key))
		if value == "" {
			return "", nil
		}
		data, err := base64.StdEncoding.DecodeString(value)
		if err != nil {
			data, err = base64.RawStdEncoding.DecodeString(value)
		}
		if err != nil {
			data, err = base64.URLEncoding.DecodeString(value)
		}
		if err != nil {
			data, err = base64.RawURLEncoding.DecodeString(value)
		}
		if err != nil {
			return "", err
		}
		return string(data), nil
	}
	configContents, err := decodeBlob("configContents")
	if err != nil {
		return providerImportRequest{}, err
	}
	authContents, err := decodeBlob("authContents")
	if err != nil {
		return providerImportRequest{}, err
	}
	request := providerImportRequest{
		Name:           values.Get("name"),
		BaseURL:        values.Get("baseUrl"),
		APIKey:         values.Get("apiKey"),
		WireAPI:        firstNonEmpty(values.Get("wireApi"), "responses"),
		RelayMode:      firstNonEmpty(values.Get("relayMode"), "pureApi"),
		ConfigContents: configContents,
		AuthContents:   authContents,
	}
	return normalizeProviderImportRequest(request)
}

func normalizeProviderImportRequest(request providerImportRequest) (providerImportRequest, error) {
	request.Name = strings.TrimSpace(request.Name)
	request.BaseURL = strings.TrimRight(strings.TrimSpace(request.BaseURL), "/")
	request.APIKey = strings.TrimSpace(request.APIKey)
	request.WireAPI = strings.ToLower(strings.TrimSpace(request.WireAPI))
	request.RelayMode = strings.TrimSpace(request.RelayMode)
	if request.Name == "" {
		return providerImportRequest{}, errors.New("供应商名称为空")
	}
	if request.BaseURL == "" {
		return providerImportRequest{}, errors.New("Base URL 为空")
	}
	if request.APIKey == "" {
		return providerImportRequest{}, errors.New("API Key 为空")
	}
	if request.WireAPI == "" {
		request.WireAPI = "responses"
	}
	if request.RelayMode == "" {
		request.RelayMode = "pureApi"
	}
	if strings.TrimSpace(request.ConfigContents) == "" {
		request.ConfigContents = buildCCSConfigToml(request.BaseURL, request.APIKey, providerImportProtocol(request.WireAPI))
	}
	if strings.TrimSpace(request.AuthContents) == "" {
		request.AuthContents = buildCCSAuthJSON(request.APIKey)
	}
	return request, nil
}

func savePendingProviderImport(request providerImportRequest) error {
	request, err := normalizeProviderImportRequest(request)
	if err != nil {
		return err
	}
	data, err := json.MarshalIndent(request, "", "  ")
	if err != nil {
		return err
	}
	return atomicWrite(pendingProviderImportPath(), data)
}

func loadPendingProviderImport() (*providerImportRequest, error) {
	data, err := os.ReadFile(pendingProviderImportPath())
	if os.IsNotExist(err) {
		return nil, nil
	}
	if err != nil {
		return nil, err
	}
	var request providerImportRequest
	if err := json.Unmarshal(data, &request); err != nil {
		return nil, err
	}
	request, err = normalizeProviderImportRequest(request)
	if err != nil {
		return nil, err
	}
	return &request, nil
}

func clearPendingProviderImport() error {
	err := os.Remove(pendingProviderImportPath())
	if os.IsNotExist(err) {
		return nil
	}
	return err
}

func confirmPendingProviderImport() (*providerImportResult, error) {
	request, err := loadPendingProviderImport()
	if err != nil || request == nil {
		return nil, err
	}
	result, err := importProviderRequest(*request)
	if err != nil {
		return nil, err
	}
	if err := clearPendingProviderImport(); err != nil {
		return nil, err
	}
	return &result, nil
}

func importProviderRequest(request providerImportRequest) (providerImportResult, error) {
	request, err := normalizeProviderImportRequest(request)
	if err != nil {
		return providerImportResult{}, err
	}
	settings := loadSettings()
	identity := ccsImportKey(request.Name, request.BaseURL)
	for _, profile := range settings.RelayProfiles {
		if ccsImportKey(profile.Name, firstNonEmpty(profile.UpstreamBaseURL, profile.BaseURL)) == identity {
			return providerImportResult{Imported: false, ProfileID: profile.ID, ProfileName: profile.Name}, nil
		}
	}
	existingIDs := map[string]bool{}
	for _, profile := range settings.RelayProfiles {
		existingIDs[profile.ID] = true
	}
	profile := relayProfile{
		ID:                     uniqueProfileID("import-"+sanitizeID(request.Name), existingIDs),
		Name:                   request.Name,
		BaseURL:                request.BaseURL,
		UpstreamBaseURL:        request.BaseURL,
		APIKey:                 request.APIKey,
		Protocol:               providerImportProtocol(request.WireAPI),
		RelayMode:              providerImportRelayMode(request.RelayMode),
		ConfigContents:         request.ConfigContents,
		AuthContents:           request.AuthContents,
		UseCommonConfig:        true,
		ModelInsertMode:        "patch",
		ImageGenerationEnabled: true,
	}
	settings.RelayProfiles = append(settings.RelayProfiles, profile)
	settings.ActiveRelayID = profile.ID
	if err := saveSettings(settings); err != nil {
		return providerImportResult{}, err
	}
	return providerImportResult{Imported: true, ProfileID: profile.ID, ProfileName: profile.Name}, nil
}

func providerImportProtocol(value string) string {
	switch strings.ToLower(strings.TrimSpace(value)) {
	case "chat", "chat_completions", "chat-completions", "openai_chat", "openai-chat":
		return "chatCompletions"
	default:
		return "responses"
	}
}

func providerImportRelayMode(value string) string {
	switch strings.ToLower(strings.TrimSpace(value)) {
	case "official":
		return "official"
	case "mixedapi", "mixed-api", "mixed_api":
		return "mixedApi"
	case "aggregate":
		return "aggregate"
	default:
		return "pureApi"
	}
}