package main

import (
	"context"
	"flag"
	"log"
	"net/http"
	"time"

	"github.com/adamveld12/gopherhole/client/public"
	"github.com/adamveld12/gopherhole/internal"
	"github.com/miekg/dns"
)

var (
	dbPath          = flag.String("db-path", ".", "Directory to write database files to")
	httpAddr        = flag.String("http-address", "0.0.0.0:80", "Bind address for http server")
	dnsAddr         = flag.String("dns-address", "0.0.0.0:53", "Bind address for dns server")
	defaultUpstream = flag.String("upstream", "1.1.1.1:53", "default upstream DNS server when no others are specified")
)

func main() {
	flag.Parse()
	log.SetFlags(log.LUTC | log.Lshortfile)

	conf := StartupConfig{
		HTTPAddr:    *httpAddr,
		DNSAddr:     *dnsAddr,
		DatabaseURL: *dbPath,
	}

	log.Printf("%+v", conf)
	store := &internal.Sqlite{
		Path: conf.DatabaseURL,
	}

	defer store.Close()

	if err := store.Open(); err != nil {
		log.Fatalf("COULD NOT OPEN SQLITE DB: %v", err)
	}

	re := &internal.RuleEngine{
		Rules: conf.Rules,
	}

	cache := &internal.Memory{}

	dnsClient := &dns.Client{
		Net:          "udp",
		DialTimeout:  time.Millisecond * 250,
		ReadTimeout:  time.Second,
		WriteTimeout: time.Second,
	}

	dm := &internal.DomainManager{
		Cache:         cache,
		Storage:       store,
		RuleEvaluator: re,
		Recursors: internal.Recursor{
			Upstreams: []string{*defaultUpstream},
			Client:    dnsClient,
		},
	}

	go func() {
		dnsSrv := &internal.DNSServer{Handler: dm}
		if err := dnsSrv.ListenAndServe(context.Background(), conf.DNSAddr); err != nil {
			log.Fatal(err)
		}
	}()

	httpApi := internal.NewAdminHandler(cache, store, re, public.Assets)
	if err := http.ListenAndServe(conf.HTTPAddr, httpApi); err != nil {
		log.Fatal(err)
	}
}