stremio/node/media-node/internal/config/config.go

package config

import (
	"fmt"
	"os"
	"strconv"
	"strings"
	"time"

	"gopkg.in/yaml.v3"
)

const (
	DefaultConfigPath      = "/etc/media-node/config.yaml"
	DefaultDataDir         = "/var/lib/media-node"
	DefaultCredentialsPath = "/etc/media-node/credentials/credentials.json"
	DefaultListen          = "0.0.0.0:8080"
)

type Config struct {
	Node     NodeConfig     `yaml:"node"`
	Master   MasterConfig   `yaml:"master"`
	Stream   StreamConfig   `yaml:"stream"`
	Media    MediaConfig    `yaml:"media"`
	Scanner  ScannerConfig  `yaml:"scanner"`
	Security SecurityConfig `yaml:"security"`
}

type NodeConfig struct {
	ID   string `yaml:"id"`
	Name string `yaml:"name"`
}

type MasterConfig struct {
	URL string `yaml:"url"`
}

type StreamConfig struct {
	Listen    string `yaml:"listen"`
	PublicURL string `yaml:"public_url"`
}

type MediaConfig struct {
	Movies []string `yaml:"movies"`
	Series []string `yaml:"series"`
}

type ScannerConfig struct {
	// FullScanInterval: duration like "6h", or "off" to disable interval scans.
	FullScanInterval string `yaml:"full_scan_interval"`
	// FullScanAt: local clock time HH:MM for nightly catch-up scan (default 03:30).
	FullScanAt string `yaml:"full_scan_at"`
}

type SecurityConfig struct {
	SessionIdleTimeout string `yaml:"session_idle_timeout"`
	MaxConcurrentPerIP int    `yaml:"max_concurrent_per_ip"`
}

type Credentials struct {
	NodeID string `json:"nodeId"`
	APIKey string `json:"apiKey"`
	Name   string `json:"name"`
}

func Load(path string) (*Config, error) {
	data, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			cfg, envErr := FromEnv()
			if envErr != nil {
				return nil, fmt.Errorf("read config: %w (and env incomplete: %v)", err, envErr)
			}
			if saveErr := Save(path, cfg); saveErr != nil {
				return applyDefaults(applyEnvOverrides(cfg)), nil
			}
			return applyDefaults(applyEnvOverrides(cfg)), nil
		}
		return nil, fmt.Errorf("read config: %w", err)
	}
	var cfg Config
	if err := yaml.Unmarshal(data, &cfg); err != nil {
		return nil, fmt.Errorf("parse config: %w", err)
	}
	return applyDefaults(applyEnvOverrides(&cfg)), nil
}

// FromEnv builds config from MEDIA_NODE_* environment variables (Docker/Unraid).
func FromEnv() (*Config, error) {
	name := strings.TrimSpace(os.Getenv("MEDIA_NODE_NAME"))
	master := strings.TrimRight(strings.TrimSpace(os.Getenv("MEDIA_NODE_MASTER_URL")), "/")
	publicURL := strings.TrimRight(strings.TrimSpace(os.Getenv("MEDIA_NODE_PUBLIC_URL")), "/")
	if name == "" || master == "" || publicURL == "" {
		return nil, fmt.Errorf("MEDIA_NODE_NAME, MEDIA_NODE_MASTER_URL and MEDIA_NODE_PUBLIC_URL are required")
	}
	listen := strings.TrimSpace(os.Getenv("MEDIA_NODE_LISTEN"))
	if listen == "" {
		listen = DefaultListen
	}
	scanAt := strings.TrimSpace(os.Getenv("MEDIA_NODE_FULL_SCAN_AT"))
	scanInterval := strings.TrimSpace(os.Getenv("MEDIA_NODE_FULL_SCAN_INTERVAL"))
	return &Config{
		Node:   NodeConfig{Name: name},
		Master: MasterConfig{URL: master},
		Stream: StreamConfig{Listen: listen, PublicURL: publicURL},
		Media: MediaConfig{
			Movies: splitPaths(os.Getenv("MEDIA_NODE_MOVIES")),
			Series: splitPaths(os.Getenv("MEDIA_NODE_SERIES")),
		},
		Scanner: ScannerConfig{
			FullScanInterval: scanInterval,
			FullScanAt:       scanAt,
		},
		Security: SecurityConfig{SessionIdleTimeout: "20m", MaxConcurrentPerIP: 64},
	}, nil
}

func applyEnvOverrides(cfg *Config) *Config {
	if v := strings.TrimSpace(os.Getenv("MEDIA_NODE_FULL_SCAN_AT")); v != "" {
		cfg.Scanner.FullScanAt = v
	}
	if v := strings.TrimSpace(os.Getenv("MEDIA_NODE_FULL_SCAN_INTERVAL")); v != "" {
		cfg.Scanner.FullScanInterval = v
	}
	return cfg
}

func applyDefaults(cfg *Config) *Config {
	if cfg.Stream.Listen == "" {
		cfg.Stream.Listen = DefaultListen
	}
	if cfg.Scanner.FullScanInterval == "" {
		cfg.Scanner.FullScanInterval = "off"
	}
	if cfg.Scanner.FullScanAt == "" {
		cfg.Scanner.FullScanAt = "03:30"
	}
	if cfg.Security.SessionIdleTimeout == "" {
		cfg.Security.SessionIdleTimeout = "20m"
	}
	if cfg.Security.MaxConcurrentPerIP == 0 {
		cfg.Security.MaxConcurrentPerIP = 64
	}
	return cfg
}

func splitPaths(raw string) []string {
	raw = strings.TrimSpace(raw)
	if raw == "" {
		return nil
	}
	var out []string
	for _, part := range strings.FieldsFunc(raw, func(r rune) bool {
		return r == ',' || r == ';' || r == '\n'
	}) {
		p := strings.TrimSpace(part)
		if p != "" {
			out = append(out, p)
		}
	}
	return out
}

// FullScanDuration returns 0 when interval scanning is disabled.
func (c *Config) FullScanDuration() time.Duration {
	raw := strings.TrimSpace(strings.ToLower(c.Scanner.FullScanInterval))
	if raw == "" || raw == "off" || raw == "0" || raw == "disabled" {
		return 0
	}
	d, err := time.ParseDuration(c.Scanner.FullScanInterval)
	if err != nil {
		return 0
	}
	return d
}

// FullScanClock returns hour and minute for the nightly scan (local timezone).
func (c *Config) FullScanClock() (hour, minute int, ok bool) {
	raw := strings.TrimSpace(c.Scanner.FullScanAt)
	if raw == "" || strings.EqualFold(raw, "off") {
		return 0, 0, false
	}
	parts := strings.Split(raw, ":")
	if len(parts) != 2 {
		return 3, 30, true
	}
	h, err1 := strconv.Atoi(parts[0])
	m, err2 := strconv.Atoi(parts[1])
	if err1 != nil || err2 != nil || h < 0 || h > 23 || m < 0 || m > 59 {
		return 3, 30, true
	}
	return h, m, true
}

func Save(path string, cfg *Config) error {
	data, err := yaml.Marshal(cfg)
	if err != nil {
		return err
	}
	return os.WriteFile(path, data, 0o600)
}