// SPDX-FileCopyrightText: 2023 The Pion community <https://pion.ly>
// SPDX-License-Identifier: MIT

package vnet

import (
	
	
	
	

	
)

var (
	errHostnameEmpty       = errors.New("host name must not be empty")
	errFailedToParseIPAddr = errors.New("failed to parse IP address")
)

type resolverConfig struct {
	LoggerFactory logging.LoggerFactory
}

type resolver struct {
	parent *resolver             // read-only
	hosts  map[string]net.IP     // requires mutex
	mutex  sync.RWMutex          // thread-safe
	log    logging.LeveledLogger // read-only
}

func newResolver( *resolverConfig) *resolver {
	 := &resolver{
		hosts: map[string]net.IP{},
		log:   .LoggerFactory.NewLogger("vnet"),
	}

	if  := .addHost("localhost", "127.0.0.1");  != nil {
		.log.Warn("failed to add localhost to resolver")
	}
	return 
}

func ( *resolver) ( *resolver) {
	.mutex.Lock()
	defer .mutex.Unlock()

	.parent = 
}

func ( *resolver) ( string,  string) error {
	.mutex.Lock()
	defer .mutex.Unlock()

	if len() == 0 {
		return errHostnameEmpty
	}
	 := net.ParseIP()
	if  == nil {
		return fmt.Errorf("%w \"%s\"", errFailedToParseIPAddr, )
	}
	.hosts[] = 
	return nil
}

func ( *resolver) ( string) (net.IP, error) {
	 := func() net.IP {
		.mutex.RLock()
		defer .mutex.RUnlock()

		if ,  := .hosts[];  {
			return 
		}
		return nil
	}()
	if  != nil {
		return , nil
	}

	// mutex must be unlocked before calling into parent resolver

	if .parent != nil {
		return .parent.()
	}

	return nil, &net.DNSError{
		Err:         "host not found",
		Name:        ,
		Server:      "vnet resolver",
		IsTimeout:   false,
		IsTemporary: false,
	}
}