package zddc

import (
	"strings"
)

// matchGlob looks up a path segment in a paths: map. Literal
// (case-insensitive) match first; falls back to a "*" segment-
// wildcard key if present. Returns nil when neither hits.
//
// Phase 2: single-segment globs only. Multi-segment keys (a/b) are
// rejected at the schema level and never reach this lookup.
func matchGlob(m map[string]ZddcFile, seg string) *ZddcFile {
	if m == nil {
		return nil
	}
	// Fast path: exact key match (case-sensitive — operator-controlled).
	if v, ok := m[seg]; ok {
		return &v
	}
	// Case-insensitive literal match for canonical-folder ergonomics
	// (operator writes `archive:`; on-disk dir may be `Archive`).
	lower := strings.ToLower(seg)
	for k, v := range m {
		if k == "*" {
			continue
		}
		if strings.ToLower(k) == lower {
			return &v
		}
	}
	// Wildcard fallback.
	if v, ok := m["*"]; ok {
		return &v
	}
	return nil
}

// mergeOverlay composes two ZddcFile values into one. `top` overrides
// `base` per-field. Maps merge key-by-key (top wins on key clash);
// scalar fields take top's value when non-zero (allowing base to fill
// in unset fields).
//
// The intended use is a stack of contributions from lowest to highest
// specificity, applied in order:
//
//	merged = empty
//	for c in ancestor_virtual_contributions {  // lowest specificity first
//	    merged = mergeOverlay(merged, c)
//	}
//	merged = mergeOverlay(merged, on_disk_at_this_level)
//
// Each successive overlay overrides what came before for the same key.
func mergeOverlay(base, top ZddcFile) ZddcFile {
	out := base

	if top.Title != "" {
		out.Title = top.Title
	}
	if top.AppsPubKey != "" {
		out.AppsPubKey = top.AppsPubKey
	}
	if top.CreatedBy != "" {
		out.CreatedBy = top.CreatedBy
	}
	if top.Inherit != nil {
		out.Inherit = top.Inherit
	}
	if top.DefaultTool != "" {
		out.DefaultTool = top.DefaultTool
	}
	if top.AutoOwn != nil {
		out.AutoOwn = top.AutoOwn
	}
	if top.Virtual != nil {
		out.Virtual = top.Virtual
	}

	out.Admins = mergeStringSlice(out.Admins, top.Admins)
	out.ACL.Allow = mergeStringSlice(out.ACL.Allow, top.ACL.Allow)
	out.ACL.Deny = mergeStringSlice(out.ACL.Deny, top.ACL.Deny)
	if top.ACL.Inherit != nil {
		out.ACL.Inherit = top.ACL.Inherit
	}

	out.ACL.Permissions = mergeStringMap(out.ACL.Permissions, top.ACL.Permissions)
	out.Apps = mergeStringMap(out.Apps, top.Apps)
	out.Tables = mergeStringMap(out.Tables, top.Tables)
	out.Display = mergeStringMap(out.Display, top.Display)

	// Roles: shallow replace if top sets any. Roles are subtree-
	// scoped principal groups; layered merge of named lists would be
	// surprising — operators expecting a clean replacement at the
	// override level is the conventional pattern.
	if len(top.Roles) > 0 {
		out.Roles = top.Roles
	}

	// Paths: top entirely replaces base if set. Recursive descent of
	// the walker is what threads ancestor Paths through to the right
	// level — merging Paths maps themselves at this layer would
	// double-apply.
	if len(top.Paths) > 0 {
		out.Paths = top.Paths
	}

	return out
}

func mergeStringMap(base, top map[string]string) map[string]string {
	if len(top) == 0 {
		return base
	}
	if len(base) == 0 {
		out := make(map[string]string, len(top))
		for k, v := range top {
			out[k] = v
		}
		return out
	}
	out := make(map[string]string, len(base)+len(top))
	for k, v := range base {
		out[k] = v
	}
	for k, v := range top {
		out[k] = v
	}
	return out
}

func mergeStringSlice(base, top []string) []string {
	if len(top) == 0 {
		return base
	}
	if len(base) == 0 {
		out := make([]string, len(top))
		copy(out, top)
		return out
	}
	// Concatenate with dedupe (preserve order: base first, then
	// top entries that weren't already in base).
	seen := make(map[string]struct{}, len(base)+len(top))
	out := make([]string, 0, len(base)+len(top))
	for _, v := range base {
		if _, ok := seen[v]; ok {
			continue
		}
		seen[v] = struct{}{}
		out = append(out, v)
	}
	for _, v := range top {
		if _, ok := seen[v]; ok {
			continue
		}
		seen[v] = struct{}{}
		out = append(out, v)
	}
	return out
}
