package application

import (
	"bufio"
	"bytes"
	"fmt"
	"log"
	"net"
	"net/http"
	"net/http/httptest"
	"os"
	"strings"
	"testing"
)

func TestLoggingMiddleware_CapturesStatusCode(t *testing.T) {
	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusNotFound)
	}))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/test", nil)
	handler.ServeHTTP(rec, req)

	if rec.Code != http.StatusNotFound {
		t.Errorf("expected status 404, got %d", rec.Code)
	}
}

func TestLoggingMiddleware_DefaultStatus(t *testing.T) {
	// When handler does not call WriteHeader, status should default to 200
	var buf bytes.Buffer
	log.SetOutput(&buf)
	defer log.SetOutput(os.Stderr)

	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Write([]byte("ok"))
	}))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/default", nil)
	handler.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Errorf("expected status 200, got %d", rec.Code)
	}

	output := buf.String()
	if !strings.Contains(output, "200") {
		t.Errorf("log should contain status 200, got: %s", output)
	}
}

func TestLoggingMiddleware_ClientIPFromRemoteAddr(t *testing.T) {
	var buf bytes.Buffer
	log.SetOutput(&buf)
	defer log.SetOutput(os.Stderr)

	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/test", nil)
	req.RemoteAddr = "192.168.1.1:12345"
	handler.ServeHTTP(rec, req)

	// In dev mode, the log won't include IP in the simple format,
	// but we verify the middleware ran without error.
	if rec.Code != http.StatusOK {
		t.Errorf("expected status 200, got %d", rec.Code)
	}
}

func TestLoggingMiddleware_XForwardedForFirstIP(t *testing.T) {
	t.Setenv("ENV", "production")

	var buf bytes.Buffer
	log.SetOutput(&buf)
	defer log.SetOutput(os.Stderr)

	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/test", nil)
	req.Header.Set("X-Forwarded-For", "10.0.0.1, 10.0.0.2, 10.0.0.3")
	handler.ServeHTTP(rec, req)

	output := buf.String()
	if !strings.Contains(output, "10.0.0.1") {
		t.Errorf("expected log to contain first IP 10.0.0.1, got: %s", output)
	}
	if strings.Contains(output, "10.0.0.2") {
		t.Errorf("log should not contain proxy IP 10.0.0.2, got: %s", output)
	}
}

func TestLoggingMiddleware_XForwardedForSingleValue(t *testing.T) {
	t.Setenv("ENV", "production")

	var buf bytes.Buffer
	log.SetOutput(&buf)
	defer log.SetOutput(os.Stderr)

	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/test", nil)
	req.Header.Set("X-Forwarded-For", "172.16.0.5")
	handler.ServeHTTP(rec, req)

	output := buf.String()
	if !strings.Contains(output, "172.16.0.5") {
		t.Errorf("expected log to contain single IP 172.16.0.5, got: %s", output)
	}
}

func TestLoggingMiddleware_ProductionJSON(t *testing.T) {
	t.Setenv("ENV", "production")

	var buf bytes.Buffer
	log.SetOutput(&buf)
	defer log.SetOutput(os.Stderr)

	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusCreated)
	}))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("POST", "/api/items", nil)
	req.RemoteAddr = "1.2.3.4:9999"
	handler.ServeHTTP(rec, req)

	output := buf.String()
	// Production mode should output JSON with structured fields
	if !strings.Contains(output, `"method":"POST"`) {
		t.Errorf("expected JSON method field, got: %s", output)
	}
	if !strings.Contains(output, `"path":"/api/items"`) {
		t.Errorf("expected JSON path field, got: %s", output)
	}
	if !strings.Contains(output, `"status":201`) {
		t.Errorf("expected JSON status 201, got: %s", output)
	}
	if !strings.Contains(output, `"ip":"1.2.3.4:9999"`) {
		t.Errorf("expected JSON ip field, got: %s", output)
	}
}

func TestLoggingMiddleware_DevHumanReadable(t *testing.T) {
	t.Setenv("ENV", "development")

	var buf bytes.Buffer
	log.SetOutput(&buf)
	defer log.SetOutput(os.Stderr)

	handler := LoggingMiddleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.WriteHeader(http.StatusOK)
	}))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest("GET", "/home", nil)
	handler.ServeHTTP(rec, req)

	output := buf.String()
	// Dev mode should be human-readable (not JSON)
	if strings.Contains(output, `"method"`) {
		t.Errorf("dev mode should not output JSON, got: %s", output)
	}
	if !strings.Contains(output, "GET") {
		t.Errorf("dev mode should contain method, got: %s", output)
	}
	if !strings.Contains(output, "/home") {
		t.Errorf("dev mode should contain path, got: %s", output)
	}
	if !strings.Contains(output, "200") {
		t.Errorf("dev mode should contain status code, got: %s", output)
	}
}

func TestResponseWriter_CapturesWriteHeader(t *testing.T) {
	rec := httptest.NewRecorder()
	rw := &responseWriter{ResponseWriter: rec, status: http.StatusOK}

	rw.WriteHeader(http.StatusForbidden)

	if rw.status != http.StatusForbidden {
		t.Errorf("expected captured status 403, got %d", rw.status)
	}
	if rec.Code != http.StatusForbidden {
		t.Errorf("expected underlying recorder status 403, got %d", rec.Code)
	}
}

// flusherRecorder is an httptest.ResponseRecorder that also implements http.Flusher.
type flusherRecorder struct {
	*httptest.ResponseRecorder
	flushed bool
}

func (f *flusherRecorder) Flush() {
	f.flushed = true
}

func TestResponseWriter_FlushDelegates(t *testing.T) {
	fr := &flusherRecorder{ResponseRecorder: httptest.NewRecorder()}
	rw := &responseWriter{ResponseWriter: fr, status: http.StatusOK}

	rw.Flush()

	if !fr.flushed {
		t.Error("expected Flush to delegate to underlying Flusher")
	}
}

func TestResponseWriter_FlushNoopWhenNotFlusher(t *testing.T) {
	// A plain ResponseWriter that does not implement http.Flusher
	rec := httptest.NewRecorder()
	// Wrap in a non-flusher wrapper
	rw := &responseWriter{ResponseWriter: nonFlusherWriter{rec}, status: http.StatusOK}

	// Should not panic
	rw.Flush()
}

type nonFlusherWriter struct {
	http.ResponseWriter
}

func TestResponseWriter_HijackError(t *testing.T) {
	rec := httptest.NewRecorder()
	rw := &responseWriter{ResponseWriter: rec, status: http.StatusOK}

	conn, brw, err := rw.Hijack()

	if err == nil {
		t.Error("expected error from Hijack when underlying writer does not support it")
	}
	if conn != nil {
		t.Error("expected nil conn")
	}
	if brw != nil {
		t.Error("expected nil bufio.ReadWriter")
	}
	if !strings.Contains(err.Error(), "http.Hijacker") {
		t.Errorf("error should mention http.Hijacker, got: %v", err)
	}
}

// hijackableWriter implements http.Hijacker for testing.
type hijackableWriter struct {
	http.ResponseWriter
	conn net.Conn
}

func (h *hijackableWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
	rw := bufio.NewReadWriter(bufio.NewReader(h.conn), bufio.NewWriter(h.conn))
	return h.conn, rw, nil
}

func TestResponseWriter_HijackDelegates(t *testing.T) {
	server, client := net.Pipe()
	defer client.Close()

	hw := &hijackableWriter{
		ResponseWriter: httptest.NewRecorder(),
		conn:           server,
	}
	rw := &responseWriter{ResponseWriter: hw, status: http.StatusOK}

	conn, brw, err := rw.Hijack()
	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if conn == nil {
		t.Error("expected non-nil conn")
	}
	if brw == nil {
		t.Error("expected non-nil bufio.ReadWriter")
	}

	// Write + read concurrently to avoid net.Pipe deadlock
	go func() {
		fmt.Fprint(brw, "hello")
		brw.Flush()
		server.Close()
	}()

	buf := make([]byte, 5)
	n, _ := client.Read(buf)
	got := string(buf[:n])
	if got != "hello" {
		t.Errorf("expected 'hello', got %q", got)
	}
}