package config

import (
	"os"
	"strings"

	lib "git.sr.ht/~cco/go-scopes"
)

// default config

type DefaultCfg = defcfg

type defcfg struct {
	name     string
	actions  []lib.ActionConfig
	children []lib.Config
}

func (cfg *defcfg) Name() string {
	return cfg.name
}

func (cfg *defcfg) SetName(n string) {
	cfg.name = n
}

func (cfg *defcfg) Actions() []lib.ActionConfig {
	return cfg.actions
}

func (cfg *defcfg) AddAction(pattern string, specs ...lib.ActionSpec) {
	act := actionConfig(pattern, specs)
	cfg.actions = append(cfg.actions, act)
}

func (cfg *defcfg) Children() []lib.Config {
	return cfg.children
}

func (cfg *defcfg) Add(c ...lib.Config) {
	cfg.children = append(cfg.children, c...)
}

func (cfg *defcfg) Starter() lib.StartProc {
	return DefaultStart
}

func (cfg *defcfg) Step() lib.StepProc {
	return DefaultStep
}

func (cfg *defcfg) MessageHandler() lib.MessageHandler {
	return DefaultMsgHandler
}

func (cfg *defcfg) DoneHandler() lib.StepProc {
	return DefaultDoneHandler
}

func Default(name string) lib.Config {
	return &defcfg{
		name: name,
	}
}

// base config

type BaseCfg = base

type base struct {
	*defcfg
	starter     lib.StartProc
	step        lib.StepProc
	msgHandler  lib.MessageHandler
	doneHandler lib.StepProc
}

func (cfg *base) Starter() lib.StartProc {
	return cfg.starter
}

func (cfg *base) Step() lib.StepProc {
	return cfg.step
}

func (cfg *base) MessageHandler() lib.MessageHandler {
	return cfg.msgHandler
}

func (cfg *base) DoneHandler() lib.StepProc {
	return cfg.doneHandler
}

// implementation-specific methods and functions

func (cfg *base) WithStep(step lib.StepProc) *base {
	cfg.step = step
	return cfg
}

func (cfg *base) WithMessageHandler(hdlr lib.MessageHandler) *base {
	cfg.msgHandler = hdlr
	return cfg
}

func (cfg *base) WithDoneHandler(hdlr lib.StepProc) *base {
	cfg.doneHandler = hdlr
	return cfg
}

func Base(name string, starter lib.StartProc) *base {
	return &base{
		defcfg: &defcfg{
			name: name,
		},
		starter:     starter,
		step:        DefaultStep,
		msgHandler:  DefaultMsgHandler,
		doneHandler: DefaultDoneHandler,
	}
}

// will be set by core.init()
var DefaultStart lib.StartProc
var DefaultStep lib.StepProc
var DefaultMsgHandler lib.MessageHandler
var DefaultDoneHandler lib.StepProc

// action configuration

type action struct {
	pattern lib.Pattern
	specs   []lib.ActionSpec
}

func (act *action) Pattern() lib.Pattern {
	return act.pattern
}

func (act *action) Specs() []lib.ActionSpec {
	return act.specs
}

func actionConfig(pat string, specs []lib.ActionSpec) *action {
	return &action{
		pattern: pattern(strings.Split(pat, "|")),
		specs:   specs,
	}
}

type pattern []string

func (p pattern) String() string {
	return strings.Join(p, "|")
}

func (p pattern) Slice() []string {
	return []string(p)
}

func Pattern(p ...string) lib.Pattern {
	return pattern(p)
}

// overridable settings

type Settings map[string]string

func (s Settings) Use(value, key string) string {
	if v, ok := os.LookupEnv("SCOPES_" + strings.ToUpper(key)); ok {
		return v
	}
	if v, ok := s[key]; ok {
		return v
	}
	return value
}