package starnet

import (
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"
)

func BenchmarkGetRequest(b *testing.B) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("OK"))
	}))
	defer server.Close()

	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		resp, err := Get(server.URL)
		if err != nil {
			b.Fatalf("Get() error: %v", err)
		}
		resp.Body().String()
		resp.Close()
	}
}

func BenchmarkGetRequestWithHeaders(b *testing.B) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("OK"))
	}))
	defer server.Close()

	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		resp, err := Get(server.URL,
			WithHeader("X-Custom", "value"),
			WithUserAgent("BenchmarkAgent"))
		if err != nil {
			b.Fatalf("Get() error: %v", err)
		}
		resp.Body().String()
		resp.Close()
	}
}

func BenchmarkPostRequest(b *testing.B) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("OK"))
	}))
	defer server.Close()

	testData := []byte("test data for benchmark")

	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		resp, err := Post(server.URL, WithBody(testData))
		if err != nil {
			b.Fatalf("Post() error: %v", err)
		}
		resp.Body().String()
		resp.Close()
	}
}

func BenchmarkJSONRequest(b *testing.B) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		w.Write([]byte(`{"status":"ok"}`))
	}))
	defer server.Close()

	type TestData struct {
		Name  string `json:"name"`
		Value int    `json:"value"`
	}

	data := TestData{Name: "test", Value: 123}

	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		resp, err := Post(server.URL, WithJSON(data))
		if err != nil {
			b.Fatalf("Post() error: %v", err)
		}
		var result map[string]string
		resp.Body().JSON(&result)
		resp.Close()
	}
}

func BenchmarkConcurrentRequests(b *testing.B) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("OK"))
	}))
	defer server.Close()

	b.ResetTimer()
	b.ReportAllocs()

	b.RunParallel(func(pb *testing.PB) {
		for pb.Next() {
			resp, err := Get(server.URL)
			if err != nil {
				b.Fatalf("Get() error: %v", err)
			}
			resp.Body().String()
			resp.Close()
		}
	})
}

func BenchmarkRequestClone(b *testing.B) {
	req := NewSimpleRequest("https://example.com", "GET").
		SetHeader("X-Custom", "value").
		AddQuery("key", "value")

	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		_ = req.Clone()
	}
}

func BenchmarkClientCreation(b *testing.B) {
	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		_ = NewClientNoErr()
	}
}

func BenchmarkRequestCreation(b *testing.B) {
	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		_ = NewSimpleRequest("https://example.com", "GET")
	}
}

func BenchmarkResponseBodyRead(b *testing.B) {
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("test response data"))
	}))
	defer server.Close()

	// Pre-fetch response
	resp, _ := Get(server.URL, WithAutoFetch(true))
	defer resp.Close()

	b.ResetTimer()
	b.ReportAllocs()

	for i := 0; i < b.N; i++ {
		_, _ = resp.Body().String()
	}
}

func BenchmarkDifferentResponseSizes(b *testing.B) {
	sizes := []int{100, 1024, 10240, 102400} // 100B, 1KB, 10KB, 100KB

	for _, size := range sizes {
		responseData := make([]byte, size)
		for i := 0; i < size; i++ {
			responseData[i] = 'A'
		}

		b.Run(fmt.Sprintf("Size_%d", size), func(b *testing.B) {
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				w.Write(responseData)
			}))
			defer server.Close()

			b.ResetTimer()
			b.ReportAllocs()

			for i := 0; i < b.N; i++ {
				resp, err := Get(server.URL)
				if err != nil {
					b.Fatalf("Get() error: %v", err)
				}
				resp.Body().Bytes()
				resp.Close()
			}
		})
	}
}