package config

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"gopkg.in/yaml.v3"
)

// Persisted is het deel van de machineconfiguratie dat in settings.yml
// staat. Pointers onderscheiden "niet gezet" (terugval op config.yml) van
// een expliciete waarde, inclusief een lege lijst of false.
// state_path hoort hier niet in: die bepaalt waar dit bestand ligt.
type Persisted struct {
	BaseURL        *string          `yaml:"base_url,omitempty"`
	Listen         *string          `yaml:"listen,omitempty"`
	TrustedProxies *[]string        `yaml:"trusted_proxies,omitempty"`
	Auth           *PersistedAuth   `yaml:"auth,omitempty"`
	Git            *PersistedGit    `yaml:"git,omitempty"`
	SSH            *PersistedSSH    `yaml:"ssh,omitempty"`
	Runner         *PersistedRunner `yaml:"runner,omitempty"`
	CI             *PersistedCI     `yaml:"ci,omitempty"`
}

// PersistedAuth is het auth-blok in settings.yml.
type PersistedAuth struct {
	Mode             *string `yaml:"mode,omitempty"`
	BaseURL          *string `yaml:"base_url,omitempty"`
	ClientID         *string `yaml:"client_id,omitempty"`
	ClientSecret     *string `yaml:"client_secret,omitempty"`
	ClientSecretFile *string `yaml:"client_secret_file,omitempty"`
	RedirectPath     *string `yaml:"redirect_path,omitempty"`
	UserAgent        *string `yaml:"user_agent,omitempty"`
	DevUser          *string `yaml:"dev_user,omitempty"`
	DevAuthID        *int64  `yaml:"dev_auth_id,omitempty"`
	TenantID         *string `yaml:"tenant_id,omitempty"`
	Issuer           *string `yaml:"issuer,omitempty"`
}

// PersistedGit is het git-blok in settings.yml.
type PersistedGit struct {
	Binary              *string `yaml:"binary,omitempty"`
	DefaultBranch       *string `yaml:"default_branch,omitempty"`
	HookBinary          *string `yaml:"hook_binary,omitempty"`
	MaintenanceInterval *string `yaml:"maintenance_interval,omitempty"`
}

// PersistedSSH is het ssh-blok in settings.yml.
type PersistedSSH struct {
	Enabled    *bool   `yaml:"enabled,omitempty"`
	Listen     *string `yaml:"listen,omitempty"`
	PublicHost *string `yaml:"public_host,omitempty"`
	PublicPort *int    `yaml:"public_port,omitempty"`
}

// PersistedRunner is het runner-blok in settings.yml.
type PersistedRunner struct {
	Name *string `yaml:"name,omitempty"`
}

// PersistedCI is het ci-blok in settings.yml. Presets blijven in
// config.yml / de runner-UI (runner-settings.json); die zitten hier
// expres niet, om geen tweede bron te maken.
type PersistedCI struct {
	Enabled          *bool   `yaml:"enabled,omitempty"`
	Docker           *string `yaml:"docker_binary,omitempty"`
	Concurrency      *int    `yaml:"concurrency,omitempty"`
	Network          *string `yaml:"network,omitempty"`
	TimeoutSec       *int    `yaml:"timeout_seconds,omitempty"`
	UpdateMaxWaitMin *int    `yaml:"update_max_wait_minutes,omitempty"`
}

// LoadSettings leest settings.yml. (nil, nil) als het bestand er niet is.
func LoadSettings(statePath string) (*Persisted, error) {
	path := filepath.Join(statePath, SettingsFile)
	b, err := os.ReadFile(path)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, nil
		}
		return nil, err
	}
	var p Persisted
	if err := yaml.Unmarshal(b, &p); err != nil {
		return nil, fmt.Errorf("%s: %w", path, err)
	}
	return &p, nil
}

// SaveSettings schrijft settings.yml atomair met mode 0600.
func SaveSettings(statePath string, p Persisted) error {
	b, err := yaml.Marshal(p)
	if err != nil {
		return err
	}
	return atomicWrite(filepath.Join(statePath, SettingsFile), b, 0o600)
}

func ptr[T any](v T) *T { return &v }

// SettingsFrom maakt de opgeslagen vorm van de huidige configuratie.
func SettingsFrom(c Config) Persisted {
	return persistFrom(c)
}

func persistFrom(c Config) Persisted {
	proxies := append([]string(nil), c.TrustedProxies...)
	auth := PersistedAuth{
		Mode:             ptr(c.Auth.Mode),
		BaseURL:          ptr(c.Auth.BaseURL),
		ClientID:         ptr(c.Auth.ClientID),
		RedirectPath:     ptr(c.Auth.RedirectPath),
		UserAgent:        ptr(c.Auth.UserAgent),
		DevUser:          ptr(c.Auth.DevUser),
		DevAuthID:        ptr(c.Auth.DevAuthID),
		TenantID:         ptr(c.Auth.TenantID),
		Issuer:           ptr(c.Auth.Issuer),
		ClientSecretFile: ptr(c.Auth.ClientSecretFile),
	}
	if strings.TrimSpace(c.Auth.ClientSecret) != "" {
		auth.ClientSecret = ptr(c.Auth.ClientSecret)
	}
	return Persisted{
		BaseURL:        ptr(c.BaseURL),
		Listen:         ptr(c.Listen),
		TrustedProxies: &proxies,
		Auth:           &auth,
		Git: &PersistedGit{
			Binary:              ptr(c.Git.Binary),
			DefaultBranch:       ptr(c.Git.DefaultBranch),
			HookBinary:          ptr(c.Git.HookBinary),
			MaintenanceInterval: ptr(c.Git.MaintenanceInterval),
		},
		SSH: &PersistedSSH{
			Enabled:    ptr(c.SSH.Enabled),
			Listen:     ptr(c.SSH.Listen),
			PublicHost: ptr(c.SSH.PublicHost),
			PublicPort: ptr(c.SSH.PublicPort),
		},
		Runner: &PersistedRunner{Name: ptr(c.Runner.Name)},
		CI: &PersistedCI{
			Enabled:          ptr(c.CI.Enabled),
			Docker:           ptr(c.CI.Docker),
			Concurrency:      ptr(c.CI.Concurrency),
			Network:          ptr(c.CI.Network),
			TimeoutSec:       ptr(c.CI.TimeoutSec),
			UpdateMaxWaitMin: ptr(c.CI.UpdateMaxWaitMin),
		},
	}
}

func applyPersisted(c *Config, p *Persisted) {
	if p == nil {
		return
	}
	if p.BaseURL != nil {
		c.BaseURL = strings.TrimRight(*p.BaseURL, "/")
	}
	if p.Listen != nil {
		c.Listen = *p.Listen
	}
	if p.TrustedProxies != nil {
		c.TrustedProxies = append([]string(nil), *p.TrustedProxies...)
	}
	if a := p.Auth; a != nil {
		if a.Mode != nil {
			c.Auth.Mode = *a.Mode
		}
		if a.BaseURL != nil {
			c.Auth.BaseURL = strings.TrimRight(*a.BaseURL, "/")
		}
		if a.ClientID != nil {
			c.Auth.ClientID = *a.ClientID
		}
		if a.ClientSecret != nil && strings.TrimSpace(*a.ClientSecret) != "" {
			c.Auth.ClientSecret = *a.ClientSecret
		}
		if a.ClientSecretFile != nil {
			c.Auth.ClientSecretFile = *a.ClientSecretFile
		}
		if a.RedirectPath != nil {
			c.Auth.RedirectPath = *a.RedirectPath
		}
		if a.UserAgent != nil {
			c.Auth.UserAgent = *a.UserAgent
		}
		if a.DevUser != nil {
			c.Auth.DevUser = *a.DevUser
		}
		if a.DevAuthID != nil {
			c.Auth.DevAuthID = *a.DevAuthID
		}
		if a.TenantID != nil {
			c.Auth.TenantID = strings.TrimSpace(*a.TenantID)
		}
		if a.Issuer != nil {
			c.Auth.Issuer = strings.TrimRight(strings.TrimSpace(*a.Issuer), "/")
		}
	}
	if g := p.Git; g != nil {
		if g.Binary != nil {
			c.Git.Binary = *g.Binary
		}
		if g.DefaultBranch != nil {
			c.Git.DefaultBranch = *g.DefaultBranch
		}
		if g.HookBinary != nil {
			c.Git.HookBinary = *g.HookBinary
		}
		if g.MaintenanceInterval != nil {
			c.Git.MaintenanceInterval = *g.MaintenanceInterval
		}
	}
	if s := p.SSH; s != nil {
		if s.Enabled != nil {
			c.SSH.Enabled = *s.Enabled
		}
		if s.Listen != nil {
			c.SSH.Listen = *s.Listen
		}
		if s.PublicHost != nil {
			c.SSH.PublicHost = *s.PublicHost
		}
		if s.PublicPort != nil {
			c.SSH.PublicPort = *s.PublicPort
		}
	}
	if r := p.Runner; r != nil && r.Name != nil {
		c.Runner.Name = strings.TrimSpace(*r.Name)
	}
	if ci := p.CI; ci != nil {
		if ci.Enabled != nil {
			c.CI.Enabled = *ci.Enabled
		}
		if ci.Docker != nil {
			c.CI.Docker = *ci.Docker
		}
		if ci.Concurrency != nil {
			c.CI.Concurrency = *ci.Concurrency
		}
		if ci.Network != nil {
			c.CI.Network = *ci.Network
		}
		if ci.TimeoutSec != nil {
			c.CI.TimeoutSec = *ci.TimeoutSec
		}
		if ci.UpdateMaxWaitMin != nil {
			c.CI.UpdateMaxWaitMin = *ci.UpdateMaxWaitMin
		}
	}
}

// MergeUpdate past een wijziging uit de UI/API toe op de huidige config
// en bouwt de nieuwe Persisted-staat (leeg gelaten geheim blijft behouden).
func MergeUpdate(cur Config, patch Persisted) (Config, Persisted) {
	next := cur
	// Een leeg nieuw geheim betekent "ongewijzigd".
	if patch.Auth != nil && patch.Auth.ClientSecret != nil && strings.TrimSpace(*patch.Auth.ClientSecret) == "" {
		patch.Auth.ClientSecret = nil
	}
	applyPersisted(&next, &patch)
	next.applyDefaults()
	saved := persistFrom(next)
	return next, saved
}
