package internalhttp

import (
	"bytes"
	"context"
	"errors"
	"io"
	"net/http"
	"net/http/httptest"
	"path/filepath"
	"runtime"
	"strings"
	"sync"
	"testing"
	"time"

	"galaxy/rtmanager/internal/api/internalhttp/handlers"
	domainruntime "galaxy/rtmanager/internal/domain/runtime"
	"galaxy/rtmanager/internal/ports"
	"galaxy/rtmanager/internal/service/cleanupcontainer"
	"galaxy/rtmanager/internal/service/patchruntime"
	"galaxy/rtmanager/internal/service/restartruntime"
	"galaxy/rtmanager/internal/service/startruntime"
	"galaxy/rtmanager/internal/service/stopruntime"

	"github.com/getkin/kin-openapi/openapi3"
	"github.com/getkin/kin-openapi/openapi3filter"
	"github.com/getkin/kin-openapi/routers"
	"github.com/getkin/kin-openapi/routers/legacy"
	"github.com/stretchr/testify/require"
)

// TestInternalRESTConformance loads the OpenAPI specification, drives
// every runtime operation against the live internal HTTP listener
// backed by stub services, and validates each response body against
// the spec via `openapi3filter.ValidateResponse`. The test catches
// drift between the wire shape produced by the handler layer and the
// frozen contract; failure-path response shapes are validated by the
// per-handler tests in `handlers/<op>_test.go`.
func TestInternalRESTConformance(t *testing.T) {
	t.Parallel()

	doc := loadConformanceSpec(t)

	router, err := legacy.NewRouter(doc)
	require.NoError(t, err)

	deps := newConformanceDeps(t)
	server, err := NewServer(newConformanceConfig(), Dependencies{
		Logger:           nil,
		Telemetry:        nil,
		Readiness:        nil,
		RuntimeRecords:   deps.records,
		StartRuntime:     deps.start,
		StopRuntime:      deps.stop,
		RestartRuntime:   deps.restart,
		PatchRuntime:     deps.patch,
		CleanupContainer: deps.cleanup,
	})
	require.NoError(t, err)

	cases := []conformanceCase{
		{
			name:   "internalListRuntimes",
			method: http.MethodGet,
			path:   "/api/v1/internal/runtimes",
		},
		{
			name:   "internalGetRuntime",
			method: http.MethodGet,
			path:   "/api/v1/internal/runtimes/" + conformanceGameID,
		},
		{
			name:        "internalStartRuntime",
			method:      http.MethodPost,
			path:        "/api/v1/internal/runtimes/" + conformanceGameID + "/start",
			contentType: "application/json",
			body:        `{"image_ref":"galaxy/game:v1.2.3"}`,
		},
		{
			name:        "internalStopRuntime",
			method:      http.MethodPost,
			path:        "/api/v1/internal/runtimes/" + conformanceGameID + "/stop",
			contentType: "application/json",
			body:        `{"reason":"admin_request"}`,
		},
		{
			name:   "internalRestartRuntime",
			method: http.MethodPost,
			path:   "/api/v1/internal/runtimes/" + conformanceGameID + "/restart",
		},
		{
			name:        "internalPatchRuntime",
			method:      http.MethodPost,
			path:        "/api/v1/internal/runtimes/" + conformanceGameID + "/patch",
			contentType: "application/json",
			body:        `{"image_ref":"galaxy/game:v1.2.4"}`,
		},
		{
			name:   "internalCleanupRuntimeContainer",
			method: http.MethodDelete,
			path:   "/api/v1/internal/runtimes/" + conformanceGameID + "/container",
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()
			runConformanceCase(t, server.handler, router, tc)
		})
	}
}

// conformanceGameID is the path variable used for every per-game
// conformance request.
const conformanceGameID = "game-conformance"

// conformanceServerURL mirrors the canonical `servers[0].url` entry in
// `rtmanager/api/internal-openapi.yaml`. The legacy router matches
// requests against this prefix; updating the spec's server URL
// requires updating this constant.
const conformanceServerURL = "http://localhost:8096"

// conformanceCase describes one request the conformance test drives.
type conformanceCase struct {
	name        string
	method      string
	path        string
	contentType string
	body        string
}

func runConformanceCase(t *testing.T, handler http.Handler, router routers.Router, tc conformanceCase) {
	t.Helper()

	// Drive the handler with the path-only form so the listener's
	// http.ServeMux matches the registered routes (which use raw paths,
	// without the OpenAPI server URL prefix).
	var bodyReader io.Reader
	if tc.body != "" {
		bodyReader = strings.NewReader(tc.body)
	}
	request := httptest.NewRequest(tc.method, tc.path, bodyReader)
	if tc.contentType != "" {
		request.Header.Set("Content-Type", tc.contentType)
	}
	request.Header.Set("X-Galaxy-Caller", "admin")

	recorder := httptest.NewRecorder()
	handler.ServeHTTP(recorder, request)
	require.Equalf(t, http.StatusOK, recorder.Code, "operation %s returned %d: %s", tc.name, recorder.Code, recorder.Body.String())

	// kin-openapi's legacy router requires the request URL to match a
	// `servers[].url` entry; rebuild the validation request with the
	// canonical local server URL declared in the spec.
	validationURL := conformanceServerURL + tc.path
	validationRequest := httptest.NewRequest(tc.method, validationURL, bodyReaderFor(tc.body))
	if tc.contentType != "" {
		validationRequest.Header.Set("Content-Type", tc.contentType)
	}
	validationRequest.Header.Set("X-Galaxy-Caller", "admin")

	route, pathParams, err := router.FindRoute(validationRequest)
	require.NoError(t, err)

	requestInput := &openapi3filter.RequestValidationInput{
		Request:    validationRequest,
		PathParams: pathParams,
		Route:      route,
		Options: &openapi3filter.Options{
			IncludeResponseStatus: true,
		},
	}
	require.NoError(t, openapi3filter.ValidateRequest(context.Background(), requestInput))

	responseInput := &openapi3filter.ResponseValidationInput{
		RequestValidationInput: requestInput,
		Status:                 recorder.Code,
		Header:                 recorder.Header(),
		Options: &openapi3filter.Options{
			IncludeResponseStatus: true,
		},
	}
	responseInput.SetBodyBytes(recorder.Body.Bytes())
	require.NoError(t, openapi3filter.ValidateResponse(context.Background(), responseInput))
}

func loadConformanceSpec(t *testing.T) *openapi3.T {
	t.Helper()

	_, thisFile, _, ok := runtime.Caller(0)
	require.True(t, ok)

	specPath := filepath.Join(filepath.Dir(thisFile), "..", "..", "..", "api", "internal-openapi.yaml")
	loader := openapi3.NewLoader()
	doc, err := loader.LoadFromFile(specPath)
	require.NoError(t, err)
	require.NoError(t, doc.Validate(context.Background()))
	return doc
}

func bodyReaderFor(raw string) io.Reader {
	if raw == "" {
		return http.NoBody
	}
	return bytes.NewBufferString(raw)
}

// conformanceDeps groups the stub collaborators handed to the listener.
type conformanceDeps struct {
	records *conformanceRecords
	start   *conformanceStart
	stop    *conformanceStop
	restart *conformanceRestart
	patch   *conformancePatch
	cleanup *conformanceCleanup
}

func newConformanceDeps(t *testing.T) *conformanceDeps {
	t.Helper()
	return &conformanceDeps{
		records: newConformanceRecords(),
		start:   &conformanceStart{},
		stop:    &conformanceStop{},
		restart: &conformanceRestart{},
		patch:   &conformancePatch{},
		cleanup: &conformanceCleanup{},
	}
}

func newConformanceConfig() Config {
	return Config{
		Addr:              ":0",
		ReadHeaderTimeout: time.Second,
		ReadTimeout:       time.Second,
		WriteTimeout:      time.Second,
		IdleTimeout:       time.Second,
	}
}

// conformanceRecord builds a canonical running record used by every
// stub service.
func conformanceRecord() domainruntime.RuntimeRecord {
	started := time.Date(2026, 4, 26, 13, 0, 0, 0, time.UTC)
	return domainruntime.RuntimeRecord{
		GameID:             conformanceGameID,
		Status:             domainruntime.StatusRunning,
		CurrentContainerID: "container-conformance",
		CurrentImageRef:    "galaxy/game:v1.2.3",
		EngineEndpoint:     "http://galaxy-game-" + conformanceGameID + ":8080",
		StatePath:          "/var/lib/galaxy/" + conformanceGameID,
		DockerNetwork:      "galaxy-engine",
		StartedAt:          &started,
		LastOpAt:           started,
		CreatedAt:          started,
	}
}

// conformanceRecords is an in-memory record store seeded with one
// canonical record so the get / list endpoints have something to
// return.
type conformanceRecords struct {
	mu     sync.Mutex
	stored map[string]domainruntime.RuntimeRecord
}

func newConformanceRecords() *conformanceRecords {
	return &conformanceRecords{
		stored: map[string]domainruntime.RuntimeRecord{
			conformanceGameID: conformanceRecord(),
		},
	}
}

func (s *conformanceRecords) Get(_ context.Context, gameID string) (domainruntime.RuntimeRecord, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	record, ok := s.stored[gameID]
	if !ok {
		return domainruntime.RuntimeRecord{}, domainruntime.ErrNotFound
	}
	return record, nil
}

func (s *conformanceRecords) Upsert(_ context.Context, _ domainruntime.RuntimeRecord) error {
	return errors.New("not used in conformance test")
}

func (s *conformanceRecords) UpdateStatus(_ context.Context, _ ports.UpdateStatusInput) error {
	return errors.New("not used in conformance test")
}

func (s *conformanceRecords) ListByStatus(_ context.Context, _ domainruntime.Status) ([]domainruntime.RuntimeRecord, error) {
	return nil, errors.New("not used in conformance test")
}

func (s *conformanceRecords) List(_ context.Context) ([]domainruntime.RuntimeRecord, error) {
	s.mu.Lock()
	defer s.mu.Unlock()
	out := make([]domainruntime.RuntimeRecord, 0, len(s.stored))
	for _, record := range s.stored {
		out = append(out, record)
	}
	return out, nil
}

// conformanceStart is the stub StartService used by the conformance
// test. Every Handle call returns the canonical record.
type conformanceStart struct{}

func (s *conformanceStart) Handle(_ context.Context, _ startruntime.Input) (startruntime.Result, error) {
	return startruntime.Result{
		Record:  conformanceRecord(),
		Outcome: "success",
	}, nil
}

type conformanceStop struct{}

func (s *conformanceStop) Handle(_ context.Context, _ stopruntime.Input) (stopruntime.Result, error) {
	rec := conformanceRecord()
	rec.Status = domainruntime.StatusStopped
	stopped := rec.LastOpAt.Add(time.Second)
	rec.StoppedAt = &stopped
	rec.LastOpAt = stopped
	return stopruntime.Result{Record: rec, Outcome: "success"}, nil
}

type conformanceRestart struct{}

func (s *conformanceRestart) Handle(_ context.Context, _ restartruntime.Input) (restartruntime.Result, error) {
	return restartruntime.Result{Record: conformanceRecord(), Outcome: "success"}, nil
}

type conformancePatch struct{}

func (s *conformancePatch) Handle(_ context.Context, in patchruntime.Input) (patchruntime.Result, error) {
	rec := conformanceRecord()
	if in.NewImageRef != "" {
		rec.CurrentImageRef = in.NewImageRef
	}
	return patchruntime.Result{Record: rec, Outcome: "success"}, nil
}

type conformanceCleanup struct{}

func (s *conformanceCleanup) Handle(_ context.Context, _ cleanupcontainer.Input) (cleanupcontainer.Result, error) {
	rec := conformanceRecord()
	rec.Status = domainruntime.StatusRemoved
	rec.CurrentContainerID = ""
	removed := rec.LastOpAt.Add(time.Minute)
	rec.RemovedAt = &removed
	rec.LastOpAt = removed
	return cleanupcontainer.Result{Record: rec, Outcome: "success"}, nil
}

// Compile-time guards: the stubs must satisfy the handler-level
// service ports plus ports.RuntimeRecordStore so the listener accepts
// them.
var (
	_ handlers.StartService     = (*conformanceStart)(nil)
	_ handlers.StopService      = (*conformanceStop)(nil)
	_ handlers.RestartService   = (*conformanceRestart)(nil)
	_ handlers.PatchService     = (*conformancePatch)(nil)
	_ handlers.CleanupService   = (*conformanceCleanup)(nil)
	_ ports.RuntimeRecordStore  = (*conformanceRecords)(nil)
)