client_test.go

package go_weather

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

func newTestClient(t *testing.T, handler http.HandlerFunc) (*Client, func()) {
	t.Helper()

	server := httptest.NewServer(handler)

	client, err := NewClient("test-key", WithHTTPClient(server.Client()), WithBaseURL(server.URL))
	if err != nil {
		t.Fatalf("NewClient failed: %v", err)
	}

	return client, server.Close
}

func TestNewClient_EmptyAPIKey(t *testing.T) {
	if _, err := NewClient(""); err == nil {
		t.Fatal("expected error for empty API key, got nil")
	}
}

func TestCurrentService_Get(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/current.json" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		if got := r.URL.Query().Get("q"); got != "New York" {
			t.Errorf("unexpected q param: %s", got)
		}

		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{
			"location": map[string]any{"name": "New York"},
			"current":  map[string]any{"temp_c": 21.0},
		})
	})
	defer cleanup()

	resp, err := client.Current.Get(context.Background(), "New York")
	if err != nil {
		t.Fatalf("Current.Get failed: %v", err)
	}
	if resp.Location.Name != "New York" {
		t.Errorf("expected location New York, got %s", resp.Location.Name)
	}
	if resp.Current.TempC != 21.0 {
		t.Errorf("expected temp_c 21.0, got %f", resp.Current.TempC)
	}
}

func TestCurrentService_Get_InvalidQuery(t *testing.T) {
	client, err := NewClient("test-key")
	if err != nil {
		t.Fatalf("NewClient failed: %v", err)
	}

	if _, err := client.Current.Get(context.Background(), ""); err == nil {
		t.Fatal("expected error for empty query, got nil")
	}
}

func TestHistoryService_Get_DecodesForecastShape(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/history.json" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}

		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{
			"location": map[string]any{"name": "London"},
			"forecast": map[string]any{
				"forecastday": []map[string]any{
					{
						"date": "2024-01-01",
						"day":  map[string]any{"avgtemp_c": 5.5},
						"astro": map[string]any{
							"sunrise": "08:00 AM",
						},
					},
				},
			},
		})
	})
	defer cleanup()

	resp, err := client.History.Get(context.Background(), HistoryRequest{
		Query: "London",
		Date:  time.Date(2024, 1, 1, 0, 0, 0, 0, time.UTC),
	})
	if err != nil {
		t.Fatalf("History.Get failed: %v", err)
	}
	if len(resp.Forecast.ForecastDay) != 1 {
		t.Fatalf("expected 1 forecastday, got %d", len(resp.Forecast.ForecastDay))
	}
	if resp.Forecast.ForecastDay[0].Day.AvgTempC != 5.5 {
		t.Errorf("expected avgtemp_c 5.5, got %f", resp.Forecast.ForecastDay[0].Day.AvgTempC)
	}
	if resp.Forecast.ForecastDay[0].Astro.Sunrise != "08:00 AM" {
		t.Errorf("expected sunrise 08:00 AM, got %s", resp.Forecast.ForecastDay[0].Astro.Sunrise)
	}
}

func TestHistoryService_Get_InvalidDate(t *testing.T) {
	client, err := NewClient("test-key")
	if err != nil {
		t.Fatalf("NewClient failed: %v", err)
	}

	if _, err := client.History.Get(context.Background(), HistoryRequest{Query: "London"}); err == nil {
		t.Fatal("expected error for zero date, got nil")
	}

	tooOld := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
	if _, err := client.History.Get(context.Background(), HistoryRequest{Query: "London", Date: tooOld}); err == nil {
		t.Fatal("expected error for date before 2010-01-01, got nil")
	}
}

func TestRawRequest_DecodesAPIError(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusBadRequest)
		_ = json.NewEncoder(w).Encode(map[string]any{
			"error": map[string]any{"code": 1006, "message": "No matching location found."},
		})
	})
	defer cleanup()

	_, err := client.Current.Get(context.Background(), "nowhere")
	if err == nil {
		t.Fatal("expected error, got nil")
	}
	if got := err.Error(); got == "unexpected status code: 400" {
		t.Errorf("expected decoded API error message, got fallback: %s", got)
	}
}

func TestSearchService_Get_URLEscapesQuery(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if got := r.URL.Query().Get("q"); got != "New York, USA" {
			t.Errorf("unexpected q param after round-trip: %s", got)
		}

		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode([]map[string]any{
			{"name": "New York"},
		})
	})
	defer cleanup()

	results, err := client.Search.Get(context.Background(), "New York, USA")
	if err != nil {
		t.Fatalf("Search.Get failed: %v", err)
	}
	if len(results) != 1 || results[0].Name != "New York" {
		t.Errorf("unexpected results: %+v", results)
	}
}

func TestForecastService_Get_DefaultsDaysAndValidatesRange(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if got := r.URL.Query().Get("days"); got != "1" {
			t.Errorf("expected default days=1, got %s", got)
		}
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{})
	})
	defer cleanup()

	if _, err := client.Forecast.Get(context.Background(), ForecastRequest{Query: "Paris"}); err != nil {
		t.Fatalf("Forecast.Get failed: %v", err)
	}

	if _, err := client.Forecast.Get(context.Background(), ForecastRequest{Query: "Paris", Days: 20}); err == nil {
		t.Fatal("expected error for days > 14, got nil")
	}
}

func TestTimezoneService_Get(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/timezone.json" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{
			"location": map[string]any{"name": "Sydney", "localtime": "2024-01-01 10:00"},
		})
	})
	defer cleanup()

	resp, err := client.Timezone.Get(context.Background(), "Sydney")
	if err != nil {
		t.Fatalf("Timezone.Get failed: %v", err)
	}
	if resp.Location.Localtime != "2024-01-01 10:00" {
		t.Errorf("unexpected localtime: %s", resp.Location.Localtime)
	}
}

func TestIPService_Get(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/ip.json" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{"ip": "1.2.3.4", "city": "Berlin"})
	})
	defer cleanup()

	resp, err := client.IP.Get(context.Background(), "1.2.3.4")
	if err != nil {
		t.Fatalf("IP.Get failed: %v", err)
	}
	if resp.City != "Berlin" {
		t.Errorf("unexpected city: %s", resp.City)
	}
}

func TestMarineService_Get_DefaultsDaysAndValidatesRange(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/marine.json" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		if got := r.URL.Query().Get("days"); got != "1" {
			t.Errorf("expected default days=1, got %s", got)
		}

		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{
			"location": map[string]any{"name": "Miami"},
			"forecast": map[string]any{
				"forecastday": []map[string]any{
					{
						"date": "2024-01-01",
						"hour": []map[string]any{
							{"time": "2024-01-01 00:00", "swell_ht_mt": 1.2, "water_temp_c": 24.5},
						},
					},
				},
			},
		})
	})
	defer cleanup()

	resp, err := client.Marine.Get(context.Background(), MarineRequest{Query: "Miami"})
	if err != nil {
		t.Fatalf("Marine.Get failed: %v", err)
	}
	if len(resp.Forecast.ForecastDay) != 1 {
		t.Fatalf("expected 1 forecastday, got %d", len(resp.Forecast.ForecastDay))
	}
	if got := resp.Forecast.ForecastDay[0].Hour[0].SwellHeightMT; got != 1.2 {
		t.Errorf("expected swell_ht_mt 1.2, got %f", got)
	}
	if got := resp.Forecast.ForecastDay[0].Hour[0].WaterTempC; got != 24.5 {
		t.Errorf("expected water_temp_c 24.5, got %f", got)
	}

	if _, err := client.Marine.Get(context.Background(), MarineRequest{Query: "Miami", Days: 10}); err == nil {
		t.Fatal("expected error for days > 7, got nil")
	}
}

func TestMarineService_Get_InvalidQuery(t *testing.T) {
	client, err := NewClient("test-key")
	if err != nil {
		t.Fatalf("NewClient failed: %v", err)
	}

	if _, err := client.Marine.Get(context.Background(), MarineRequest{}); err == nil {
		t.Fatal("expected error for empty query, got nil")
	}
}

func TestAstronomyService_Get(t *testing.T) {
	client, cleanup := newTestClient(t, func(w http.ResponseWriter, r *http.Request) {
		if r.URL.Path != "/astronomy.json" {
			t.Errorf("unexpected path: %s", r.URL.Path)
		}
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(map[string]any{
			"astronomy": map[string]any{"astro": map[string]any{"sunrise": "07:00 AM"}},
		})
	})
	defer cleanup()

	resp, err := client.Astronomy.Get(context.Background(), AstronomyRequest{Query: "Paris"})
	if err != nil {
		t.Fatalf("Astronomy.Get failed: %v", err)
	}
	if resp.Astronomy.Astro.Sunrise != "07:00 AM" {
		t.Errorf("unexpected sunrise: %s", resp.Astronomy.Astro.Sunrise)
	}
}

func TestWithTimeout(t *testing.T) {
	client, err := NewClient("test-key", WithTimeout(5*time.Second))
	if err != nil {
		t.Fatalf("NewClient failed: %v", err)
	}
	if client.httpClient.Timeout != 5*time.Second {
		t.Errorf("expected timeout 5s, got %s", client.httpClient.Timeout)
	}
}