package hetzner

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

func TestSetRRSetRecordsUsesSetRecordsAction(t *testing.T) {
	t.Parallel()
	type capturedRequest struct {
		Method        string
		Path          string
		Authorization string
		Records       []Record
	}
	captured := make(chan capturedRequest, 1)
	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var body struct {
			Records []Record `json:"records"`
		}
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		captured <- capturedRequest{
			Method:        r.Method,
			Path:          r.URL.Path,
			Authorization: r.Header.Get("Authorization"),
			Records:       body.Records,
		}
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusCreated)
		_, _ = w.Write([]byte(`{"action":{"status":"running"}}`))
	}))
	defer api.Close()

	client := New(api.URL)
	err := client.SetRRSetRecords(
		context.Background(),
		"test-token",
		"123",
		"home",
		"A",
		[]Record{{Value: "198.51.100.42", Comment: "DynDNS"}},
	)
	if err != nil {
		t.Fatalf("set RRSet records: %v", err)
	}
	request := <-captured
	if request.Method != http.MethodPost {
		t.Errorf("unexpected method: got %s, want POST", request.Method)
	}
	if request.Path != "/zones/123/rrsets/home/A/actions/set_records" {
		t.Errorf("unexpected path: %s", request.Path)
	}
	if request.Authorization != "Bearer test-token" {
		t.Errorf("unexpected authorization header: %q", request.Authorization)
	}
	if len(request.Records) != 1 || request.Records[0].Value != "198.51.100.42" || request.Records[0].Comment != "DynDNS" {
		t.Errorf("unexpected records payload: %#v", request.Records)
	}
}

func TestUpdateRecordCommentsAlwaysSendsComment(t *testing.T) {
	t.Parallel()
	captured := make(chan map[string]any, 1)
	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var body map[string]any
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		body["method"] = r.Method
		body["path"] = r.URL.Path
		captured <- body
		w.WriteHeader(http.StatusCreated)
	}))
	defer api.Close()

	client := New(api.URL)
	if err := client.UpdateRecordComments(context.Background(), "test-token", "123", "home", "A", []Record{{Value: "198.51.100.42"}}); err != nil {
		t.Fatalf("update record comment: %v", err)
	}
	request := <-captured
	if request["method"] != http.MethodPost || request["path"] != "/zones/123/rrsets/home/A/actions/update_records" {
		t.Fatalf("unexpected request: %#v", request)
	}
	records, ok := request["records"].([]any)
	if !ok || len(records) != 1 {
		t.Fatalf("unexpected records payload: %#v", request["records"])
	}
	record, ok := records[0].(map[string]any)
	if !ok {
		t.Fatalf("unexpected record payload: %#v", records[0])
	}
	comment, exists := record["comment"]
	if !exists || comment != "" {
		t.Errorf("empty comment must be sent explicitly, got %#v", record)
	}
}

func TestChangeRRSetTTLUsesDedicatedAction(t *testing.T) {
	t.Parallel()
	captured := make(chan map[string]any, 1)
	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		var body map[string]any
		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
		body["method"] = r.Method
		body["path"] = r.URL.Path
		captured <- body
		w.WriteHeader(http.StatusCreated)
	}))
	defer api.Close()

	client := New(api.URL)
	if err := client.ChangeRRSetTTL(context.Background(), "test-token", "123", "home", "A", 300); err != nil {
		t.Fatalf("change RRSet TTL: %v", err)
	}
	request := <-captured
	if request["method"] != http.MethodPost || request["path"] != "/zones/123/rrsets/home/A/actions/change_ttl" || request["ttl"] != float64(300) {
		t.Fatalf("unexpected request: %#v", request)
	}
}

func TestDeleteRRSetUsesRRSetEndpoint(t *testing.T) {
	t.Parallel()
	captured := make(chan *http.Request, 1)
	api := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		captured <- r
		w.WriteHeader(http.StatusNoContent)
	}))
	defer api.Close()

	client := New(api.URL)
	if err := client.DeleteRRSet(context.Background(), "test-token", "123", "www", "CNAME"); err != nil {
		t.Fatalf("delete RRSet: %v", err)
	}
	request := <-captured
	if request.Method != http.MethodDelete || request.URL.Path != "/zones/123/rrsets/www/CNAME" || request.Header.Get("Authorization") != "Bearer test-token" {
		t.Fatalf("unexpected request: %s %s %q", request.Method, request.URL.Path, request.Header.Get("Authorization"))
	}
}