package httpapi

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

	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/alerts"
	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/conditions"
	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/forecasts"
	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/observations"
	"gitea.maximumdirect.net/ejr/weatherapi/internal/application/units"
	"gitea.maximumdirect.net/ejr/weatherapi/internal/core/ports"
	"gitea.maximumdirect.net/ejr/weatherapi/internal/platform/constants"
)

type fakeObservationRepo struct {
	summary       ports.ObservationCurrentConditionsMetric
	summaryWindow time.Duration

	observations []ports.ObservationRecordMetric
	recentCount  int
}

func (f *fakeObservationRepo) GetCurrentConditionsSummary(_ context.Context, window time.Duration) (ports.ObservationCurrentConditionsMetric, error) {
	f.summaryWindow = window
	return f.summary, nil
}

func (f *fakeObservationRepo) ListRecentObservations(_ context.Context, count int) ([]ports.ObservationRecordMetric, error) {
	f.recentCount = count
	return f.observations, nil
}

type fakeForecastRepo struct {
	periods  []ports.ForecastPeriodMetric
	gotTS    time.Time
	gotLimit int
}

func (f *fakeForecastRepo) ListForecastPeriodsAt(_ context.Context, ts time.Time, limit int) ([]ports.ForecastPeriodMetric, error) {
	f.gotTS = ts
	f.gotLimit = limit
	return f.periods, nil
}

type fakeAlertRepo struct{}

func (fakeAlertRepo) ListCurrentAlerts(context.Context) ([]ports.AlertRecord, error) {
	return nil, nil
}

func newTestUnitRegistry(t *testing.T) *units.Registry {
	t.Helper()

	reg := units.NewRegistry()
	if err := reg.Register(units.StaticFactory{UnitSystem: constants.UnitSystemUS, Converter: units.USConverter{}}); err != nil {
		t.Fatalf("register us converter: %v", err)
	}
	if err := reg.Register(units.StaticFactory{UnitSystem: constants.UnitSystemMetric, Converter: units.MetricConverter{}}); err != nil {
		t.Fatalf("register metric converter: %v", err)
	}
	return reg
}

func newTestHandler(t *testing.T, obsRepo *fakeObservationRepo, fcRepo *fakeForecastRepo) http.Handler {
	t.Helper()

	reg := newTestUnitRegistry(t)
	return NewServer(
		observations.NewService(obsRepo, reg),
		conditions.NewService(obsRepo, reg, constants.ObservationWindow),
		forecasts.NewService(fcRepo, reg, constants.ForecastQueryLimit),
		alerts.NewService(fakeAlertRepo{}),
	).Handler()
}

func TestLegacyObservationsCurrentPathRemoved(t *testing.T) {
	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})

	w := httptest.NewRecorder()
	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations/current", nil))
	if w.Code != http.StatusNotFound {
		t.Fatalf("expected 404 for removed /observations/current, got %d", w.Code)
	}
}

func TestConditionsCurrentDefaultsToUSUnits(t *testing.T) {
	tempC := 20.0
	appTempC := 15.0
	dewpointC := 10.0
	relHumidity := 81.0
	windKmh := 10.0
	windDir := 270.0
	conditionCode := 63
	isDay := true

	obsRepo := &fakeObservationRepo{
		summary: ports.ObservationCurrentConditionsMetric{
			TemperatureC:         &tempC,
			ApparentTemperatureC: &appTempC,
			DewpointC:            &dewpointC,
			RelativeHumidity:     &relHumidity,
			WindSpeedKmh:         &windKmh,
			WindDirectionDegrees: &windDir,
			ConditionCode:        &conditionCode,
			IsDay:                &isDay,
		},
	}
	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})

	w := httptest.NewRecorder()
	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	if got := payload["temperatureF"].(float64); got != 68.0 {
		t.Fatalf("expected temperatureF=68.0, got %v", got)
	}
	if got := payload["apparentTemperatureF"].(float64); got != 59.0 {
		t.Fatalf("expected apparentTemperatureF=59.0, got %v", got)
	}
	if got := payload["dewpointF"].(float64); got != 50.0 {
		t.Fatalf("expected dewpointF=50.0, got %v", got)
	}
	if got := payload["windSpeedMph"].(float64); got != 6.2 {
		t.Fatalf("expected windSpeedMph=6.2, got %v", got)
	}
	if got := payload["relativeHumidityPercent"].(float64); got != 81.0 {
		t.Fatalf("expected relativeHumidityPercent=81.0, got %v", got)
	}
	if got := payload["windDirectionDegrees"].(float64); got != 270.0 {
		t.Fatalf("expected windDirectionDegrees=270.0, got %v", got)
	}
	if got := payload["conditionCode"].(float64); got != 63 {
		t.Fatalf("expected conditionCode=63, got %v", got)
	}
	if got := payload["conditionText"].(string); got != "Rain" {
		t.Fatalf("expected conditionText=Rain, got %v", got)
	}
	if got := payload["isDay"].(bool); !got {
		t.Fatalf("expected isDay=true, got %v", got)
	}
	if _, exists := payload["temperatureC"]; exists {
		t.Fatalf("did not expect metric key temperatureC in default US response")
	}

	if obsRepo.summaryWindow != constants.ObservationWindow {
		t.Fatalf("expected observation window %s, got %s", constants.ObservationWindow, obsRepo.summaryWindow)
	}
}

func TestConditionsCurrentSupportsMetricUnits(t *testing.T) {
	tempC := 20.0
	windKmh := 10.0
	conditionCode := 63
	isDay := false
	obsRepo := &fakeObservationRepo{
		summary: ports.ObservationCurrentConditionsMetric{
			TemperatureC:  &tempC,
			WindSpeedKmh:  &windKmh,
			ConditionCode: &conditionCode,
			IsDay:         &isDay,
		},
	}
	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})

	w := httptest.NewRecorder()
	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current?units=metric", nil))
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	if got := payload["temperatureC"].(float64); got != 20.0 {
		t.Fatalf("expected temperatureC=20.0, got %v", got)
	}
	if got := payload["windSpeedKmh"].(float64); got != 10.0 {
		t.Fatalf("expected windSpeedKmh=10.0, got %v", got)
	}
	if got := payload["conditionCode"].(float64); got != 63 {
		t.Fatalf("expected conditionCode=63, got %v", got)
	}
	if got := payload["conditionText"].(string); got != "Rain" {
		t.Fatalf("expected conditionText=Rain, got %v", got)
	}
	if got := payload["isDay"].(bool); got {
		t.Fatalf("expected isDay=false, got %v", got)
	}
	if _, exists := payload["temperatureF"]; exists {
		t.Fatalf("did not expect US key temperatureF in metric response")
	}
}

func TestConditionsCurrentOmitsConditionFieldsWhenNoObservations(t *testing.T) {
	obsRepo := &fakeObservationRepo{
		summary: ports.ObservationCurrentConditionsMetric{},
	}
	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})

	w := httptest.NewRecorder()
	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	if _, exists := payload["conditionCode"]; exists {
		t.Fatalf("expected conditionCode omitted when no observations")
	}
	if _, exists := payload["conditionText"]; exists {
		t.Fatalf("expected conditionText omitted when no observations")
	}
	if _, exists := payload["isDay"]; exists {
		t.Fatalf("expected isDay omitted when no observations")
	}
}

func TestConditionsCurrentConditionTextUsesNilDayFallback(t *testing.T) {
	conditionCode := 0
	obsRepo := &fakeObservationRepo{
		summary: ports.ObservationCurrentConditionsMetric{
			ConditionCode: &conditionCode,
		},
	}
	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})

	w := httptest.NewRecorder()
	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/conditions/current", nil))
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	if got := payload["conditionText"].(string); got != "Sunny" {
		t.Fatalf("expected conditionText=Sunny, got %v", got)
	}
	if _, exists := payload["isDay"]; exists {
		t.Fatalf("expected isDay omitted when summary isDay is nil")
	}
}

func TestObservationsDefaultsToMetricAndDefaultCount(t *testing.T) {
	tempC := 10.0
	windKmh := 16.0
	stationID := "KSTL"
	stationName := "St Louis"
	textDescription := "Cloudy"

	obsRepo := &fakeObservationRepo{
		observations: []ports.ObservationRecordMetric{
			{
				EventID:         "evt-1",
				StationID:       &stationID,
				StationName:     &stationName,
				Timestamp:       time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
				ConditionCode:   3,
				TextDescription: &textDescription,
				TemperatureC:    &tempC,
				WindSpeedKmh:    &windKmh,
				PresentWeather:  []ports.ObservationPresentWeatherMetric{{Raw: map[string]any{"wx": "rain"}}},
			},
		},
	}
	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})

	w := httptest.NewRecorder()
	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations", nil))
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}

	if obsRepo.recentCount != constants.DefaultObservationCount {
		t.Fatalf("expected default count %d, got %d", constants.DefaultObservationCount, obsRepo.recentCount)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	observationsList := payload["observations"].([]any)
	first := observationsList[0].(map[string]any)

	if got := first["temperatureC"].(float64); got != 10.0 {
		t.Fatalf("expected temperatureC=10.0, got %v", got)
	}
	if got := first["windSpeedKmh"].(float64); got != 16.0 {
		t.Fatalf("expected windSpeedKmh=16.0, got %v", got)
	}
	if _, exists := first["temperatureF"]; exists {
		t.Fatalf("did not expect US key temperatureF in metric response")
	}
	if got := first["conditionCode"].(float64); got != 3 {
		t.Fatalf("expected conditionCode=3, got %v", got)
	}

	pw := first["presentWeather"].([]any)
	raw := pw[0].(map[string]any)["raw"].(map[string]any)
	if got := raw["wx"]; got != "rain" {
		t.Fatalf("expected presentWeather raw payload preserved, got %v", got)
	}
}

func TestObservationsSupportsUSUnitsAndCountOverride(t *testing.T) {
	tempC := 10.0
	windKmh := 16.09344
	obsRepo := &fakeObservationRepo{
		observations: []ports.ObservationRecordMetric{
			{
				EventID:       "evt-1",
				Timestamp:     time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
				ConditionCode: 1,
				TemperatureC:  &tempC,
				WindSpeedKmh:  &windKmh,
			},
		},
	}
	server := newTestHandler(t, obsRepo, &fakeForecastRepo{})

	w := httptest.NewRecorder()
	server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, "/observations?count=2&units=us", nil))
	if w.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d", w.Code)
	}
	if obsRepo.recentCount != 2 {
		t.Fatalf("expected count override 2, got %d", obsRepo.recentCount)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	first := payload["observations"].([]any)[0].(map[string]any)
	if got := first["temperatureF"].(float64); got != 50.0 {
		t.Fatalf("expected temperatureF=50.0, got %v", got)
	}
	if got := first["windSpeedMph"].(float64); got != 10.0 {
		t.Fatalf("expected windSpeedMph=10.0, got %v", got)
	}
	if _, exists := first["temperatureC"]; exists {
		t.Fatalf("did not expect metric key temperatureC in US response")
	}
}

func TestObservationsCountValidation(t *testing.T) {
	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})

	cases := []string{
		"/observations?count=0",
		"/observations?count=-1",
		"/observations?count=abc",
		"/observations?count=101",
	}
	for _, path := range cases {
		w := httptest.NewRecorder()
		server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
		if w.Code != http.StatusBadRequest {
			t.Fatalf("expected 400 for %s, got %d", path, w.Code)
		}
	}
}

func TestInvalidUnitsReturn400(t *testing.T) {
	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})

	cases := []string{
		"/conditions/current?units=bad",
		"/observations?units=bad",
		"/forecast?timestamp=2026-03-17T12:30:00Z&units=bad",
	}
	for _, path := range cases {
		w := httptest.NewRecorder()
		server.ServeHTTP(w, httptest.NewRequest(http.MethodGet, path, nil))
		if w.Code != http.StatusBadRequest {
			t.Fatalf("expected 400 for %s, got %d", path, w.Code)
		}
	}
}

func TestForecastInvalidTimestampReturns400(t *testing.T) {
	server := newTestHandler(t, &fakeObservationRepo{}, &fakeForecastRepo{})

	req := httptest.NewRequest(http.MethodGet, "/forecast?timestamp=bad-time", nil)
	w := httptest.NewRecorder()
	server.ServeHTTP(w, req)

	if w.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d", w.Code)
	}

	var payload map[string]any
	if err := json.Unmarshal(w.Body.Bytes(), &payload); err != nil {
		t.Fatalf("decode response: %v", err)
	}
	if payload["code"] != "invalid_request" {
		t.Fatalf("expected invalid_request code, got %v", payload["code"])
	}
}

func TestForecastUnitSelection(t *testing.T) {
	tempC := 0.0
	tempMinC := -1.0
	tempMaxC := 1.0
	appTempC := -2.0
	windKmh := 10.0
	gustKmh := 16.09344
	name := "Now"

	fcRepo := &fakeForecastRepo{
		periods: []ports.ForecastPeriodMetric{
			{
				PeriodIndex:          1,
				StartTime:            time.Date(2026, 3, 17, 12, 0, 0, 0, time.UTC),
				EndTime:              time.Date(2026, 3, 17, 13, 0, 0, 0, time.UTC),
				Name:                 &name,
				ConditionCode:        1,
				TemperatureC:         &tempC,
				TemperatureCMin:      &tempMinC,
				TemperatureCMax:      &tempMaxC,
				ApparentTemperatureC: &appTempC,
				WindSpeedKmh:         &windKmh,
				WindGustKmh:          &gustKmh,
			},
		},
	}
	server := newTestHandler(t, &fakeObservationRepo{}, fcRepo)

	wUS := httptest.NewRecorder()
	server.ServeHTTP(wUS, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z", nil))
	if wUS.Code != http.StatusOK {
		t.Fatalf("expected US forecast 200, got %d", wUS.Code)
	}

	var usPayload map[string]any
	if err := json.Unmarshal(wUS.Body.Bytes(), &usPayload); err != nil {
		t.Fatalf("decode us forecast: %v", err)
	}
	usPeriod := usPayload["periods"].([]any)[0].(map[string]any)
	if got := usPeriod["temperatureF"].(float64); got != 32.0 {
		t.Fatalf("expected temperatureF=32.0, got %v", got)
	}
	if got := usPeriod["windSpeedMph"].(float64); got != 6.2 {
		t.Fatalf("expected windSpeedMph=6.2, got %v", got)
	}
	if _, exists := usPeriod["temperatureC"]; exists {
		t.Fatalf("did not expect metric key temperatureC in US response")
	}

	wMetric := httptest.NewRecorder()
	server.ServeHTTP(wMetric, httptest.NewRequest(http.MethodGet, "/forecast?timestamp=2026-03-17T12:30:00Z&units=metric", nil))
	if wMetric.Code != http.StatusOK {
		t.Fatalf("expected metric forecast 200, got %d", wMetric.Code)
	}

	var metricPayload map[string]any
	if err := json.Unmarshal(wMetric.Body.Bytes(), &metricPayload); err != nil {
		t.Fatalf("decode metric forecast: %v", err)
	}
	metricPeriod := metricPayload["periods"].([]any)[0].(map[string]any)
	if got := metricPeriod["temperatureC"].(float64); got != 0.0 {
		t.Fatalf("expected temperatureC=0.0, got %v", got)
	}
	if got := metricPeriod["windSpeedKmh"].(float64); got != 10.0 {
		t.Fatalf("expected windSpeedKmh=10.0, got %v", got)
	}
	if _, exists := metricPeriod["temperatureF"]; exists {
		t.Fatalf("did not expect US key temperatureF in metric response")
	}

	if fcRepo.gotLimit != constants.ForecastQueryLimit {
		t.Fatalf("expected forecast query limit %d, got %d", constants.ForecastQueryLimit, fcRepo.gotLimit)
	}
	if fcRepo.gotTS.IsZero() {
		t.Fatalf("expected forecast timestamp passed to repo")
	}
}