// Package config loads and saves hamlab's JSON config file.
package config

import (
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"sync"
	"time"

	"hamlab/internal/store"
)

// Token is an API token another Ham Lab (a hub) uses to manage this host. Only the
// SHA-256 of the token is kept.
type Token struct {
	Name    string    `json:"name"`
	Hash    string    `json:"hash"`
	Created time.Time `json:"created"`
	// Scope is what the token may do. "" is everything (a hub's token: full control of
	// this machine). ScopeSensorsRead only reads sensors — what a dashboard gets.
	Scope string `json:"scope,omitempty"`
	// Sensors narrows a sensors:read token to the IDs these patterns match. Empty is all.
	Sensors []string `json:"sensors,omitempty"`
}

const ScopeSensorsRead = "sensors:read"

// Node is a remote Ham Lab this host (as hub) manages. The token is the one that
// node issued to us; the fingerprint pins its self-signed certificate.
type Node struct {
	Name        string    `json:"name"`
	URL         string    `json:"url"`
	Fingerprint string    `json:"fingerprint,omitempty"`
	Token       string    `json:"token"`
	Added       time.Time `json:"added"`
}

type Config struct {
	Listen       string  `json:"listen"`
	PasswordHash string  `json:"password_hash"`
	TLS          string  `json:"tls,omitempty"` // "auto" → self-signed cert in the data dir; "" → plain HTTP
	Tokens       []Token `json:"tokens,omitempty"`
	Nodes        []Node  `json:"nodes,omitempty"`

	path string
	mu   sync.Mutex
}

// Candidates lists where config.json may live under a home directory, preferred first:
// the XDG location, then ~/apps/hamlab, which installs before v0.2 used.
func Candidates(home string) []string {
	return []string{filepath.Join(home, ".config", "hamlab", "config.json"), filepath.Join(home, "apps", "hamlab", "config.json")}
}

// DefaultPath is the config used when neither -config nor $HAMLAB_CONFIG says otherwise:
// whichever candidate exists, else the preferred one.
func DefaultPath() string {
	home, _ := os.UserHomeDir()
	c := Candidates(home)
	for _, p := range c {
		if _, err := os.Stat(p); err == nil {
			return p
		}
	}
	return c[0]
}

func Default(path string) *Config {
	return &Config{Listen: "127.0.0.1:8100", path: path}
}

// Load reads the config at path. A missing file yields the defaults.
func Load(path string) (*Config, error) {
	c := Default(path)
	b, err := os.ReadFile(path)
	if errors.Is(err, os.ErrNotExist) {
		return c, nil
	}
	if err != nil {
		return nil, err
	}
	if err := json.Unmarshal(b, c); err != nil {
		return nil, fmt.Errorf("parse %s: %w", path, err)
	}
	return c, nil
}

func (c *Config) Path() string    { return c.path }
func (c *Config) DataDir() string { return filepath.Dir(c.path) }

func (c *Config) Save() error {
	c.mu.Lock()
	defer c.mu.Unlock()
	return c.save()
}

func (c *Config) save() error {
	if err := os.MkdirAll(c.DataDir(), 0o700); err != nil {
		return err
	}
	b, err := json.MarshalIndent(c, "", "  ")
	if err != nil {
		return err
	}
	return store.WriteFileAtomic(c.path, append(b, '\n'), 0o600)
}

// Update applies fn under the lock and saves.
func (c *Config) Update(fn func(*Config)) error {
	c.mu.Lock()
	defer c.mu.Unlock()
	fn(c)
	return c.save()
}

// View reads under the lock.
func (c *Config) View(fn func(*Config)) {
	c.mu.Lock()
	defer c.mu.Unlock()
	fn(c)
}