package dns

import (
	"errors"
	"fmt"
	"math/rand"
	"strings"

	"github.com/miekg/dns"
)

// Query records
func (q *Query) Lookup() {
	for {
		// Create result
		result := &Result{
			Domain:    q.Domain,
			Subdomain: q.Subdomain,
		}

		// Create message
		message := new(dns.Msg)

		// Set question
		switch q.IPv6 {
		case false:
			message.SetQuestion(dns.Fqdn(q.Subdomain), dns.TypeA)
		case true:
			message.SetQuestion(dns.Fqdn(q.Subdomain), dns.TypeAAAA)
		}

		// Choose random resolver
		resolver := q.Resolvers[rand.Intn(len(q.Resolvers))]

		// Query response
		resp, _, err := q.Client.Exchange(message, resolver)
		if err != nil {
			// Ratelimited
			if strings.ContainsAny(err.Error(), "i/o timeout") {
				continue
			}

			result.Error = err
			q.Results <- result
			return
		}

		// Verify check
		if q.Verify {
			if Verify(q.Subdomain) {
				result.Error = errors.New(fmt.Sprintf("Could not verify %s", q.Subdomain))
				q.Results <- result
				return
			}
		}

		// Store IPs
		var ips []string

		// Go through answers
		for _, answer := range resp.Answer {
			// Map record
			switch q.IPv6 {
			case false:
				record, ok := answer.(*dns.A)
				if !ok {
					continue
				}

				// Append IPv4
				ips = append(ips, record.A.String())
			case true:
				record, ok := answer.(*dns.AAAA)
				if !ok {
					continue
				}

				// Append IPv4
				ips = append(ips, record.AAAA.String())
			}
		}

		// No IPs found
		if len(ips) < 1 {
			result.Error = errors.New(fmt.Sprintf("No IPs found for %s", q.Domain))
			q.Results <- result
			return
		}

		// Send result
		switch q.IPv6 {
		case false:
			result.IPv4 = ips
		case true:
			result.IPv6 = ips
		}
		q.Results <- result
		return
	}
}