package dhcpsvc

import (
	"fmt"
	"net"
	"net/netip"
	"slices"
	"sync"
	"sync/atomic"
	"time"

	"github.com/AdguardTeam/golibs/errors"
	"golang.org/x/exp/maps"
)

// DHCPServer is a DHCP server for both IPv4 and IPv6 address families.
type DHCPServer struct {
	// enabled indicates whether the DHCP server is enabled and can provide
	// information about its clients.
	enabled *atomic.Bool

	// localTLD is the top-level domain name to use for resolving DHCP clients'
	// hostnames.
	localTLD string

	// leasesMu protects the leases index as well as leases in the interfaces.
	leasesMu *sync.RWMutex

	// leases stores the DHCP leases for quick lookups.
	leases *leaseIndex

	// interfaces4 is the set of IPv4 interfaces sorted by interface name.
	interfaces4 netInterfacesV4

	// interfaces6 is the set of IPv6 interfaces sorted by interface name.
	interfaces6 netInterfacesV6

	// icmpTimeout is the timeout for checking another DHCP server's presence.
	icmpTimeout time.Duration
}

// New creates a new DHCP server with the given configuration.  It returns an
// error if the given configuration can't be used.
//
// TODO(e.burkov):  Use.
func New(conf *Config) (srv *DHCPServer, err error) {
	if !conf.Enabled {
		// TODO(e.burkov):  Perhaps return [Empty]?
		return nil, nil
	}

	// TODO(e.burkov):  Add validations scoped to the network interfaces set.
	ifaces4 := make(netInterfacesV4, 0, len(conf.Interfaces))
	ifaces6 := make(netInterfacesV6, 0, len(conf.Interfaces))

	ifaceNames := maps.Keys(conf.Interfaces)
	slices.Sort(ifaceNames)

	var i4 *netInterfaceV4
	var i6 *netInterfaceV6

	for _, ifaceName := range ifaceNames {
		iface := conf.Interfaces[ifaceName]

		i4, err = newNetInterfaceV4(ifaceName, iface.IPv4)
		if err != nil {
			return nil, fmt.Errorf("interface %q: ipv4: %w", ifaceName, err)
		} else if i4 != nil {
			ifaces4 = append(ifaces4, i4)
		}

		i6 = newNetInterfaceV6(ifaceName, iface.IPv6)
		if i6 != nil {
			ifaces6 = append(ifaces6, i6)
		}
	}

	enabled := &atomic.Bool{}
	enabled.Store(conf.Enabled)

	srv = &DHCPServer{
		enabled:     enabled,
		localTLD:    conf.LocalDomainName,
		leasesMu:    &sync.RWMutex{},
		leases:      newLeaseIndex(),
		interfaces4: ifaces4,
		interfaces6: ifaces6,
		icmpTimeout: conf.ICMPTimeout,
	}

	// TODO(e.burkov):  Load leases.

	return srv, nil
}

// type check
//
// TODO(e.burkov):  Uncomment when the [Interface] interface is implemented.
// var _ Interface = (*DHCPServer)(nil)

// Enabled implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) Enabled() (ok bool) {
	return srv.enabled.Load()
}

// Leases implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) Leases() (leases []*Lease) {
	srv.leasesMu.RLock()
	defer srv.leasesMu.RUnlock()

	for _, iface := range srv.interfaces4 {
		for _, lease := range iface.leases {
			leases = append(leases, lease.Clone())
		}
	}
	for _, iface := range srv.interfaces6 {
		for _, lease := range iface.leases {
			leases = append(leases, lease.Clone())
		}
	}

	return leases
}

// HostByIP implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) HostByIP(ip netip.Addr) (host string) {
	srv.leasesMu.RLock()
	defer srv.leasesMu.RUnlock()

	if l, ok := srv.leases.leaseByAddr(ip); ok {
		return l.Hostname
	}

	return ""
}

// MACByIP implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) MACByIP(ip netip.Addr) (mac net.HardwareAddr) {
	srv.leasesMu.RLock()
	defer srv.leasesMu.RUnlock()

	if l, ok := srv.leases.leaseByAddr(ip); ok {
		return l.HWAddr
	}

	return nil
}

// IPByHost implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) IPByHost(host string) (ip netip.Addr) {
	srv.leasesMu.RLock()
	defer srv.leasesMu.RUnlock()

	if l, ok := srv.leases.leaseByName(host); ok {
		return l.IP
	}

	return netip.Addr{}
}

// Reset implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) Reset() (err error) {
	srv.leasesMu.Lock()
	defer srv.leasesMu.Unlock()

	for _, iface := range srv.interfaces4 {
		iface.reset()
	}
	for _, iface := range srv.interfaces6 {
		iface.reset()
	}
	srv.leases.clear()

	return nil
}

// AddLease implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) AddLease(l *Lease) (err error) {
	defer func() { err = errors.Annotate(err, "adding lease: %w") }()

	addr := l.IP
	iface, err := srv.ifaceForAddr(addr)
	if err != nil {
		// Don't wrap the error since there is already an annotation deferred.
		return err
	}

	srv.leasesMu.Lock()
	defer srv.leasesMu.Unlock()

	return srv.leases.add(l, iface)
}

// UpdateStaticLease implements the [Interface] interface for *DHCPServer.
//
// TODO(e.burkov):  Support moving leases between interfaces.
func (srv *DHCPServer) UpdateStaticLease(l *Lease) (err error) {
	defer func() { err = errors.Annotate(err, "updating static lease: %w") }()

	addr := l.IP
	iface, err := srv.ifaceForAddr(addr)
	if err != nil {
		// Don't wrap the error since there is already an annotation deferred.
		return err
	}

	srv.leasesMu.Lock()
	defer srv.leasesMu.Unlock()

	return srv.leases.update(l, iface)
}

// RemoveLease implements the [Interface] interface for *DHCPServer.
func (srv *DHCPServer) RemoveLease(l *Lease) (err error) {
	defer func() { err = errors.Annotate(err, "removing lease: %w") }()

	addr := l.IP
	iface, err := srv.ifaceForAddr(addr)
	if err != nil {
		// Don't wrap the error since there is already an annotation deferred.
		return err
	}

	srv.leasesMu.Lock()
	defer srv.leasesMu.Unlock()

	return srv.leases.remove(l, iface)
}

// ifaceForAddr returns the handled network interface for the given IP address,
// or an error if no such interface exists.
func (srv *DHCPServer) ifaceForAddr(addr netip.Addr) (iface *netInterface, err error) {
	var ok bool
	if addr.Is4() {
		iface, ok = srv.interfaces4.find(addr)
	} else {
		iface, ok = srv.interfaces6.find(addr)
	}
	if !ok {
		return nil, fmt.Errorf("no interface for ip %s", addr)
	}

	return iface, nil
}