config.go

package main

import (
	"errors"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var (
	errAPIKeyRequired      = errors.New("api_key is required")
	errInputPromptRequired = errors.New("input_prompt is required")
)

// Config holds all configuration for the LLM action
type Config struct {
	BaseURL       string
	APIKey        string
	Model         string
	SkipSSLVerify bool
	CACert        string
	SystemPrompt  string
	InputPrompt   string
	ToolSchema    string
	Temperature   float64
	MaxTokens     int
	Debug         bool
	Headers       map[string]string
}

// LoadConfig loads configuration from environment variables
func LoadConfig() (*Config, error) {
	config := &Config{
		BaseURL:     os.Getenv("INPUT_BASE_URL"),
		APIKey:      os.Getenv("INPUT_API_KEY"),
		Model:       os.Getenv("INPUT_MODEL"),
		Temperature: 0.7,  // default
		MaxTokens:   1000, // default
	}

	// Set default base URL if not provided
	if config.BaseURL == "" {
		config.BaseURL = "https://api.openai.com/v1"
	}

	// Validate required inputs
	if config.APIKey == "" {
		return nil, errAPIKeyRequired
	}

	// Load input prompt (supports text, file path, or URL)
	inputPromptInput := os.Getenv("INPUT_INPUT_PROMPT")
	if inputPromptInput == "" {
		return nil, errInputPromptRequired
	}
	loadedInputPrompt, err := LoadPrompt(inputPromptInput)
	if err != nil {
		return nil, fmt.Errorf("failed to load input_prompt: %w", err)
	}
	config.InputPrompt = loadedInputPrompt

	// Load system prompt (supports text, file path, or URL)
	systemPromptInput := os.Getenv("INPUT_SYSTEM_PROMPT")
	if systemPromptInput != "" {
		loadedPrompt, err := LoadPrompt(systemPromptInput)
		if err != nil {
			return nil, fmt.Errorf("failed to load system_prompt: %w", err)
		}
		config.SystemPrompt = loadedPrompt
	}

	// Load CA certificate (supports content, file path, or URL)
	caCertInput := os.Getenv("INPUT_CA_CERT")
	if caCertInput != "" {
		loadedCACert, err := LoadContent(caCertInput)
		if err != nil {
			return nil, fmt.Errorf("failed to load ca_cert: %w", err)
		}
		config.CACert = loadedCACert
	}

	// Load tool schema (supports text, file path, or URL with template rendering)
	toolSchemaInput := os.Getenv("INPUT_TOOL_SCHEMA")
	if toolSchemaInput != "" {
		loadedSchema, err := LoadPrompt(toolSchemaInput)
		if err != nil {
			return nil, fmt.Errorf("failed to load tool_schema: %w", err)
		}
		config.ToolSchema = loadedSchema
	}

	// Parse optional parameters
	if err := config.parseTemperature(os.Getenv("INPUT_TEMPERATURE")); err != nil {
		return nil, err
	}

	if err := config.parseMaxTokens(os.Getenv("INPUT_MAX_TOKENS")); err != nil {
		return nil, err
	}

	if err := config.parseSkipSSL(os.Getenv("INPUT_SKIP_SSL_VERIFY")); err != nil {
		return nil, err
	}

	if err := config.parseDebug(os.Getenv("INPUT_DEBUG")); err != nil {
		return nil, err
	}

	if err := config.parseHeaders(os.Getenv("INPUT_HEADERS")); err != nil {
		return nil, err
	}

	return config, nil
}

// parseTemperature parses temperature string to float64
func (c *Config) parseTemperature(s string) error {
	if s == "" {
		return nil
	}

	temp, err := strconv.ParseFloat(s, 64)
	if err != nil {
		return fmt.Errorf("invalid temperature value: %w", err)
	}
	c.Temperature = temp
	return nil
}

// parseMaxTokens parses max tokens string to int
func (c *Config) parseMaxTokens(s string) error {
	if s == "" {
		return nil
	}

	tokens, err := strconv.Atoi(s)
	if err != nil {
		return fmt.Errorf("invalid max_tokens value: %w", err)
	}
	if tokens < 0 {
		return fmt.Errorf("max_tokens must be positive")
	}
	c.MaxTokens = tokens
	return nil
}

// parseSkipSSL parses skip SSL verify string to bool
func (c *Config) parseSkipSSL(s string) error {
	if s == "" {
		return nil
	}

	skip, err := strconv.ParseBool(s)
	if err != nil {
		return fmt.Errorf("invalid skip_ssl_verify value: %w", err)
	}
	c.SkipSSLVerify = skip
	return nil
}

// parseDebug parses debug string to bool
func (c *Config) parseDebug(s string) error {
	if s == "" {
		return nil
	}

	debug, err := strconv.ParseBool(s)
	if err != nil {
		return fmt.Errorf("invalid debug value: %w", err)
	}
	c.Debug = debug
	return nil
}

// parseHeaders parses headers string to map
// Format: "Header1:Value1,Header2:Value2" or multiline "Header1:Value1\nHeader2:Value2"
func (c *Config) parseHeaders(s string) error {
	if s == "" {
		return nil
	}

	c.Headers = make(map[string]string)

	// Support both comma-separated and newline-separated formats
	// First normalize newlines to commas for consistent parsing
	normalized := strings.ReplaceAll(s, "\n", ",")

	pairs := strings.Split(normalized, ",")
	for _, pair := range pairs {
		pair = strings.TrimSpace(pair)
		if pair == "" {
			continue
		}

		// Split on first colon only (value may contain colons)
		idx := strings.Index(pair, ":")
		if idx == -1 {
			return fmt.Errorf("invalid header format: %q (expected 'Key:Value')", pair)
		}

		key := strings.TrimSpace(pair[:idx])
		value := strings.TrimSpace(pair[idx+1:])

		if key == "" {
			return fmt.Errorf("empty header key in: %q", pair)
		}

		c.Headers[key] = value
	}

	return nil
}