package pdns

import (
	"context"
	"encoding/json"
	"net/http"
	"net/http/httptest"
	"strconv"
	"strings"
	"testing"
)

func TestListZonesSendsAPIKey(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/v1/servers/localhost/zones" {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}
		if got := r.Header.Get("X-API-Key"); got != "secret" {
			t.Fatalf("unexpected api key: %q", got)
		}
		_ = json.NewEncoder(w).Encode([]Zone{{ID: "example.org.", Name: "example.org."}})
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	zones, err := client.ListZones(context.Background())
	if err != nil {
		t.Fatalf("ListZones returned error: %v", err)
	}
	if len(zones) != 1 || zones[0].ID != "example.org." {
		t.Fatalf("unexpected zones: %#v", zones)
	}
}

func TestCreateRRSetPatchesZone(t *testing.T) {
	var patchCount int

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !strings.HasPrefix(r.URL.Path, "/api/v1/servers/localhost/zones/example.org.") {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}

		switch r.Method {
		case http.MethodGet:
			writeZoneWithRRSets(t, w, 10, nil)
		case http.MethodPatch:
			patchCount++
			var payload struct {
				RRSets []changeRRSet `json:"rrsets"`
			}
			if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
				t.Fatalf("decode request: %v", err)
			}
			if len(payload.RRSets) != 1 || payload.RRSets[0].ChangeType != "REPLACE" {
				t.Fatalf("unexpected payload: %#v", payload)
			}
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected method: %s", r.Method)
		}
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	err := client.CreateRRSet(context.Background(), "example.org.", RRSet{
		Name: "www.example.org.",
		Type: "A",
		TTL:  300,
		Records: []Record{{
			Content: "192.0.2.10",
		}},
	})
	if err != nil {
		t.Fatalf("CreateRRSet returned error: %v", err)
	}
	if patchCount != 1 {
		t.Fatalf("expected one patch, got %d", patchCount)
	}
}

func TestCreateRRSetMergesMultiValueRecordTypes(t *testing.T) {
	var patched RRSet
	var getCount int

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !strings.HasPrefix(r.URL.Path, "/api/v1/servers/localhost/zones/example.org.") {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}

		switch r.Method {
		case http.MethodGet:
			getCount++
			writeZoneWithRRSets(t, w, 10, []RRSet{{
				Name: "example.org.",
				Type: "NS",
				TTL:  3600,
				Records: []Record{{
					Content: "ns1.example.org.",
				}},
			}})
		case http.MethodPatch:
			var payload struct {
				RRSets []changeRRSet `json:"rrsets"`
			}
			if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
				t.Fatalf("decode request: %v", err)
			}
			if payload.RRSets[0].Type == "NS" {
				patched = RRSet{
					Name:    payload.RRSets[0].Name,
					Type:    payload.RRSets[0].Type,
					TTL:     payload.RRSets[0].TTL,
					Records: payload.RRSets[0].Records,
				}
			}
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected method: %s", r.Method)
		}
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	err := client.CreateRRSet(context.Background(), "example.org.", RRSet{
		Name: "example.org.",
		Type: "NS",
		TTL:  3600,
		Records: []Record{{
			Content: "ns2.example.org.",
		}},
	})
	if err != nil {
		t.Fatalf("CreateRRSet returned error: %v", err)
	}
	if getCount == 0 {
		t.Fatal("expected zone read before merge")
	}
	if len(patched.Records) != 2 {
		t.Fatalf("expected merged records, got %#v", patched.Records)
	}
	if patched.Records[0].Content != "ns1.example.org." || patched.Records[1].Content != "ns2.example.org." {
		t.Fatalf("unexpected merged records: %#v", patched.Records)
	}
}

func TestCreateRRSetDoesNotMergeSingleValueRecordTypes(t *testing.T) {
	var patched RRSet

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if !strings.HasPrefix(r.URL.Path, "/api/v1/servers/localhost/zones/www.example.org.") {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}

		switch r.Method {
		case http.MethodGet:
			writeZoneWithRRSets(t, w, 11, []RRSet{{
				Name: "www.example.org.",
				Type: "CNAME",
				TTL:  3600,
				Records: []Record{{
					Content: "old.example.org.",
				}},
			}})
		case http.MethodPatch:
			var payload struct {
				RRSets []changeRRSet `json:"rrsets"`
			}
			if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
				t.Fatalf("decode request: %v", err)
			}
			if payload.RRSets[0].Type == "CNAME" {
				patched = RRSet{
					Name:    payload.RRSets[0].Name,
					Type:    payload.RRSets[0].Type,
					TTL:     payload.RRSets[0].TTL,
					Records: payload.RRSets[0].Records,
				}
			}
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected method: %s", r.Method)
		}
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	err := client.CreateRRSet(context.Background(), "www.example.org.", RRSet{
		Name: "www.example.org.",
		Type: "CNAME",
		TTL:  3600,
		Records: []Record{{
			Content: "new.example.org.",
		}},
	})
	if err != nil {
		t.Fatalf("CreateRRSet returned error: %v", err)
	}
	if len(patched.Records) != 1 || patched.Records[0].Content != "new.example.org." {
		t.Fatalf("expected replacement record only, got %#v", patched.Records)
	}
}

func TestGetServerUsesConfiguredServerID(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/api/v1/servers/localhost" {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}
		_ = json.NewEncoder(w).Encode(Server{ID: "localhost", Version: "5.0.0"})
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	got, err := client.GetServer(context.Background())
	if err != nil {
		t.Fatalf("GetServer returned error: %v", err)
	}
	if got.ID != "localhost" {
		t.Fatalf("unexpected server: %#v", got)
	}
}

func TestCreateZonePostsZone(t *testing.T) {
	var posted bool
	var put bool

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodPost:
			posted = true
			if r.URL.Path != "/api/v1/servers/localhost/zones" {
				t.Fatalf("unexpected path: %s", r.URL.Path)
			}

			var payload Zone
			if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
				t.Fatalf("decode request: %v", err)
			}
			if payload.Name != "example.org." || payload.Kind != "Native" {
				t.Fatalf("unexpected payload: %#v", payload)
			}
			if payload.SOAEditAPI != soaEditAPIIncrease {
				t.Fatalf("unexpected soa_edit_api: %q", payload.SOAEditAPI)
			}
			w.WriteHeader(http.StatusCreated)
			_ = json.NewEncoder(w).Encode(payload)
		case http.MethodPut:
			put = true
			if r.URL.Path != "/api/v1/servers/localhost/zones/example.org." {
				t.Fatalf("unexpected path: %s", r.URL.Path)
			}
			var payload Zone
			if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
				t.Fatalf("decode request: %v", err)
			}
			if payload.SOAEditAPI != soaEditAPIIncrease {
				t.Fatalf("unexpected soa_edit_api: %q", payload.SOAEditAPI)
			}
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected method: %s", r.Method)
		}
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	created, err := client.CreateZone(context.Background(), Zone{Name: "example.org.", Kind: "Native"})
	if err != nil {
		t.Fatalf("CreateZone returned error: %v", err)
	}
	if created.Name != "example.org." {
		t.Fatalf("unexpected zone: %#v", created)
	}
	if !posted || !put {
		t.Fatalf("expected POST and follow-up PUT, posted=%v put=%v", posted, put)
	}
}

func TestEnsureAllZonesSOAEditAPIUpdatesAllZones(t *testing.T) {
	var updated []string

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch r.Method {
		case http.MethodGet:
			if r.URL.Path != "/api/v1/servers/localhost/zones" {
				t.Fatalf("unexpected path: %s", r.URL.Path)
			}
			_ = json.NewEncoder(w).Encode([]Zone{
				{ID: "already.example.org.", Name: "already.example.org.", SOAEditAPI: soaEditAPIIncrease},
				{ID: "missing.example.org.", Name: "missing.example.org."},
				{ID: "", Name: "fallback.example.org.", SOAEditAPI: "DEFAULT"},
			})
		case http.MethodPut:
			var payload Zone
			if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
				t.Fatalf("decode request: %v", err)
			}
			if payload.SOAEditAPI != soaEditAPIIncrease {
				t.Fatalf("unexpected soa_edit_api: %q", payload.SOAEditAPI)
			}
			updated = append(updated, strings.TrimPrefix(r.URL.Path, "/api/v1/servers/localhost/zones/"))
			w.WriteHeader(http.StatusNoContent)
		default:
			t.Fatalf("unexpected method: %s", r.Method)
		}
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	if err := client.EnsureAllZonesSOAEditAPI(context.Background()); err != nil {
		t.Fatalf("EnsureAllZonesSOAEditAPI returned error: %v", err)
	}

	if len(updated) != 3 {
		t.Fatalf("expected three updates, got %#v", updated)
	}
	if updated[0] != "already.example.org." || updated[1] != "missing.example.org." || updated[2] != "fallback.example.org." {
		t.Fatalf("unexpected updated zones: %#v", updated)
	}
}

func TestSetZoneSOAEditAPIUsesPUT(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPut {
			t.Fatalf("unexpected method: %s", r.Method)
		}
		if r.URL.Path != "/api/v1/servers/localhost/zones/example.org." {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}

		var payload Zone
		if err := json.NewDecoder(r.Body).Decode(&payload); err != nil {
			t.Fatalf("decode request: %v", err)
		}
		if payload.SOAEditAPI != soaEditAPIIncrease {
			t.Fatalf("unexpected soa_edit_api: %q", payload.SOAEditAPI)
		}
		w.WriteHeader(http.StatusNoContent)
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	if err := client.SetZoneSOAEditAPI(context.Background(), "example.org."); err != nil {
		t.Fatalf("SetZoneSOAEditAPI returned error: %v", err)
	}
}

func TestDeleteZoneDeletesZone(t *testing.T) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodDelete {
			t.Fatalf("unexpected method: %s", r.Method)
		}
		if r.URL.Path != "/api/v1/servers/localhost/zones/example.org." {
			t.Fatalf("unexpected path: %s", r.URL.Path)
		}
		w.WriteHeader(http.StatusNoContent)
	}))
	defer server.Close()

	client := NewClient(server.URL, "secret", "localhost", server.Client())
	if err := client.DeleteZone(context.Background(), "example.org."); err != nil {
		t.Fatalf("DeleteZone returned error: %v", err)
	}
}

func writeZoneWithRRSets(t *testing.T, w http.ResponseWriter, serial uint64, rrsets []RRSet) {
	t.Helper()

	allRRSets := []RRSet{{
		Name: "example.org.",
		Type: "SOA",
		TTL:  3600,
		Records: []Record{{
			Content: "ns1.example.org. hostmaster.example.org. " + strconv.FormatUint(serial, 10) + " 3600 600 604800 300",
		}},
	}}
	allRRSets = append(allRRSets, rrsets...)

	_ = json.NewEncoder(w).Encode(Zone{
		ID:     "example.org.",
		Name:   "example.org.",
		Serial: serial,
		RRSets: allRRSets,
	})
}