//go:build standalone

package checker

import (
	"context"
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"strings"
	"sync"

	"github.com/miekg/dns"

	sdk "git.happydns.org/checker-sdk-go/checker"
)

func (p *authoritativeConsistencyProvider) RenderForm() []sdk.CheckerOptionField {
	return []sdk.CheckerOptionField{
		{
			Id:          "zone",
			Type:        "string",
			Label:       "Zone name",
			Placeholder: "example.com",
			Required:    true,
			Description: "Apex name of the zone whose authoritative servers should be cross-checked.",
		},
	}
}

func (p *authoritativeConsistencyProvider) ParseForm(r *http.Request) (sdk.CheckerOptions, error) {
	zone := strings.TrimSpace(r.FormValue("zone"))
	if zone == "" {
		return nil, fmt.Errorf("zone is required")
	}
	fqdn := dns.Fqdn(zone)

	resolver := interactiveResolver()

	ctx := r.Context()
	var (
		wg        sync.WaitGroup
		nsRecords []*dns.NS
		soaRecord *dns.SOA
		nsErr     error
		soaErr    error
	)
	wg.Add(2)
	go func() {
		defer wg.Done()
		nsRecords, nsErr = lookupRecords[*dns.NS](ctx, resolver, fqdn, dns.TypeNS, false)
	}()
	go func() {
		defer wg.Done()
		soas, err := lookupRecords[*dns.SOA](ctx, resolver, fqdn, dns.TypeSOA, false)
		if err != nil {
			soaErr = err
			return
		}
		if len(soas) > 0 {
			soaRecord = soas[0]
		}
	}()
	wg.Wait()

	if nsErr != nil {
		return nil, fmt.Errorf("NS lookup for %s: %w", zone, nsErr)
	}
	if len(nsRecords) == 0 {
		return nil, fmt.Errorf("no NS records found for %s", zone)
	}
	if soaErr != nil {
		return nil, fmt.Errorf("SOA lookup for %s: %w", zone, soaErr)
	}

	svcType := "abstract.Origin"
	payload := originService{SOA: soaRecord, NameServers: nsRecords}
	if soaRecord == nil {
		svcType = "abstract.NSOnlyOrigin"
	}

	body, err := json.Marshal(payload)
	if err != nil {
		return nil, fmt.Errorf("marshal origin service: %w", err)
	}

	svc := serviceMessage{
		Type:    svcType,
		Service: body,
	}

	return sdk.CheckerOptions{
		"domain_name": strings.TrimSuffix(fqdn, "."),
		"service":     svc,
	}, nil
}

var (
	resolverOnce sync.Once
	resolverAddr string

	interactiveClient = &dns.Client{Timeout: dnsTimeout}
)

func interactiveResolver() string {
	resolverOnce.Do(func() {
		cfg, err := dns.ClientConfigFromFile("/etc/resolv.conf")
		if err != nil || len(cfg.Servers) == 0 {
			resolverAddr = net.JoinHostPort("1.1.1.1", "53")
			return
		}
		resolverAddr = net.JoinHostPort(cfg.Servers[0], cfg.Port)
	})
	return resolverAddr
}

func lookupRecords[T dns.RR](ctx context.Context, resolver, fqdn string, qtype uint16, edns bool) ([]T, error) {
	msg := new(dns.Msg)
	msg.SetQuestion(fqdn, qtype)
	msg.RecursionDesired = true
	if edns {
		msg.SetEdns0(4096, true)
	}

	in, _, err := interactiveClient.ExchangeContext(ctx, msg, resolver)
	if err != nil {
		return nil, err
	}
	if in.Rcode != dns.RcodeSuccess && in.Rcode != dns.RcodeNameError {
		return nil, fmt.Errorf("rcode %s", dns.RcodeToString[in.Rcode])
	}

	var out []T
	for _, rr := range in.Answer {
		if t, ok := rr.(T); ok {
			out = append(out, t)
		}
	}
	return out, nil
}