package model

import (
	"slices"
	"sort"
)

// Linked zones (docs/views.md#linked-zones): zones of the same name in
// different views whose shared records Jarl keeps in step. Each zone
// keeps its own copy of every shared record (with the same SharedID), so
// named, validation and rendering see ordinary zones. A record with
// SharedID 0 in a linked zone is local to its view: an override of the
// shared records of the same name and type there.

// LinkMembers returns the zones of a link group in view order.
func (s *State) LinkMembers(group int64) []*Zone {
	if group == 0 {
		return nil
	}
	var out []*Zone
	for _, z := range s.Zones {
		if z.LinkGroup == group {
			out = append(out, z)
		}
	}
	s.SortByView(out)
	return out
}

// LinkedWith returns the other zones z is linked with, in view order.
func (s *State) LinkedWith(z *Zone) []*Zone {
	var out []*Zone
	for _, o := range s.LinkMembers(z.LinkGroup) {
		if o.ID != z.ID {
			out = append(out, o)
		}
	}
	return out
}

// AnyLinked reports whether any zone is linked.
func (s *State) AnyLinked() bool {
	for _, z := range s.Zones {
		if z.LinkGroup != 0 {
			return true
		}
	}
	return false
}

// SortByView sorts zones in view order.
func (s *State) SortByView(zs []*Zone) {
	pos := func(z *Zone) int {
		if v := s.Views[z.ViewID]; v != nil {
			return v.Position
		}
		return -1
	}
	sort.Slice(zs, func(i, j int) bool {
		if a, b := pos(zs[i]), pos(zs[j]); a != b {
			return a < b
		}
		return zs[i].ID < zs[j].ID
	})
}

// RRset returns the records of one name and type in a zone, by ID.
func (s *State) RRset(zoneID int64, name, typ string) []*Record {
	var out []*Record
	for _, r := range s.Records {
		if r.ZoneID == zoneID && r.Name == name && r.Type == typ {
			out = append(out, r)
		}
	}
	slices.SortFunc(out, func(a, b *Record) int { return int(a.ID - b.ID) })
	return out
}

// HasLocal reports whether a linked zone overrides the shared records of
// one name and type with records of its own.
func (s *State) HasLocal(zoneID int64, name, typ string) bool {
	for _, r := range s.Records {
		if r.ZoneID == zoneID && r.Name == name && r.Type == typ && r.SharedID == 0 {
			return true
		}
	}
	return false
}

// SharedRecords returns a zone's shared records of one name and type,
// by SharedID.
func (s *State) SharedRecords(zoneID int64, name, typ string) []*Record {
	var out []*Record
	for _, r := range s.Records {
		if r.ZoneID == zoneID && r.Name == name && r.Type == typ && r.SharedID != 0 {
			out = append(out, r)
		}
	}
	slices.SortFunc(out, func(a, b *Record) int { return int(a.SharedID - b.SharedID) })
	return out
}