package httpapi

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"

	"github.com/descrybe/descrybe-v2/apps/api/internal/billing"
	"github.com/descrybe/descrybe-v2/apps/api/internal/catalog"
	"github.com/descrybe/descrybe-v2/apps/api/internal/processing"
	"github.com/go-chi/chi/v5"
	"github.com/google/uuid"
)

func TestV1OKDataMetaEnvelope(t *testing.T) {
	t.Parallel()
	rec := httptest.NewRecorder()
	v1OK(rec, http.StatusOK, []map[string]any{{"id": "1"}}, map[string]any{
		"page": 1, "limit": 25, "total": 1, "totalPages": 1,
	})
	if rec.Code != http.StatusOK {
		t.Fatalf("status=%d", rec.Code)
	}
	var body map[string]any
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatal(err)
	}
	if _, ok := body["data"]; !ok {
		t.Fatalf("missing data: %s", rec.Body.String())
	}
	meta, ok := body["meta"].(map[string]any)
	if !ok {
		t.Fatalf("missing meta: %s", rec.Body.String())
	}
	if meta["page"].(float64) != 1 || meta["limit"].(float64) != 25 {
		t.Fatalf("meta=%v", meta)
	}
}

func TestV1OKOmitsNilMeta(t *testing.T) {
	t.Parallel()
	rec := httptest.NewRecorder()
	v1OK(rec, http.StatusOK, map[string]any{"process_id": "abc"}, nil)
	var body map[string]any
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatal(err)
	}
	if _, ok := body["meta"]; ok {
		t.Fatalf("meta should be omitted: %s", rec.Body.String())
	}
	data, _ := body["data"].(map[string]any)
	if data["process_id"] != "abc" {
		t.Fatalf("data=%v", data)
	}
}

func TestV1ErrCodedEnvelope(t *testing.T) {
	t.Parallel()
	rec := httptest.NewRecorder()
	v1Err(rec, http.StatusBadRequest, "validation_error", "'items' array is required")
	var body struct {
		Error struct {
			Code    string `json:"code"`
			Message string `json:"message"`
		} `json:"error"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatal(err)
	}
	if body.Error.Code != "validation_error" || !strings.Contains(body.Error.Message, "items") {
		t.Fatalf("got %+v", body.Error)
	}
}

func TestV1ErrFromProcessingDoesNotDoubleWrite(t *testing.T) {
	t.Parallel()
	rec := httptest.NewRecorder()
	v1ErrFromProcessing(rec, errors.New("unexpected backend failure"))
	if rec.Code != http.StatusBadRequest {
		t.Fatalf("status=%d", rec.Code)
	}
	raw := rec.Body.Bytes()
	var body struct {
		Error struct {
			Code    string `json:"code"`
			Message string `json:"message"`
		} `json:"error"`
	}
	if err := json.Unmarshal(raw, &body); err != nil {
		t.Fatalf("body must be a single JSON object: %v raw=%q", err, string(raw))
	}
	if body.Error.Code != "validation_error" {
		t.Fatalf("got %+v", body.Error)
	}
	if strings.Contains(string(raw), `{"error":"could not start processing job"}`) {
		t.Fatalf("flat Error envelope must not precede coded body: %s", raw)
	}
}

func TestHandleV1StartProcessRequiresItemsOrRawIDs(t *testing.T) {
	t.Parallel()
	s := &Server{}
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	ctx = context.WithValue(ctx, ctxUserID, uuid.MustParse("22222222-2222-2222-2222-222222222222"))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(`{"processing_type":"full"}`))
	req = req.WithContext(ctx)
	s.handleV1StartProcess(rec, req)
	if rec.Code != http.StatusBadRequest {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	if !strings.Contains(rec.Body.String(), `"code":"validation_error"`) {
		t.Fatalf("body=%s", rec.Body.String())
	}
	if !strings.Contains(rec.Body.String(), "items") {
		t.Fatalf("body=%s", rec.Body.String())
	}
}

func TestHandleV1StartProcessRejectsMissingEAN(t *testing.T) {
	t.Parallel()
	s := &Server{}
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	ctx = context.WithValue(ctx, ctxUserID, uuid.MustParse("22222222-2222-2222-2222-222222222222"))

	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(`{"items":[{"title":"x"}]}`))
	req = req.WithContext(ctx)
	s.handleV1StartProcess(rec, req)
	if rec.Code != http.StatusBadRequest {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	if !strings.Contains(rec.Body.String(), "ean") {
		t.Fatalf("body=%s", rec.Body.String())
	}
}

func TestHandleV1StartProcessItemsEANReturnsProcessID(t *testing.T) {
	t.Parallel()
	jobID := uuid.MustParse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
	rawID := uuid.MustParse("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb")
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	uid := uuid.MustParse("22222222-2222-2222-2222-222222222222")

	var sawEANs []string
	var enqueued uuid.UUID
	s := &Server{
		testEnsureRawV1Items: func(_ context.Context, companyID uuid.UUID, items []catalog.V1ProcessItem) ([]uuid.UUID, []catalog.EnsureRawResult, []string, error) {
			if companyID != cid {
				t.Fatalf("company=%s", companyID)
			}
			for _, it := range items {
				sawEANs = append(sawEANs, it.EAN)
			}
			return []uuid.UUID{rawID}, []catalog.EnsureRawResult{{RawProductID: rawID, EAN: items[0].EAN}}, nil, nil
		},
		testStartJobs: func(_ context.Context, companyID, userID uuid.UUID, rawIDs []uuid.UUID, processingType string) ([]processing.Job, error) {
			if companyID != cid || userID != uid {
				t.Fatalf("tenant cid=%s uid=%s", companyID, userID)
			}
			if len(rawIDs) != 1 || rawIDs[0] != rawID {
				t.Fatalf("rawIDs=%v", rawIDs)
			}
			if processingType != "full" {
				t.Fatalf("type=%q", processingType)
			}
			return []processing.Job{{ID: jobID, Status: "pending", TotalProducts: 1, ProcessingType: "full"}}, nil
		},
		testEnqueueJob: func(_ context.Context, id uuid.UUID) error {
			enqueued = id
			return nil
		},
	}

	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	ctx = context.WithValue(ctx, ctxUserID, uid)
	body := `{"processing_type":"full","items":[{"ean":"1234567890123","title":"Wireless earbuds"}]}`
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(body))
	req = req.WithContext(ctx)
	s.handleV1StartProcess(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	var envelope struct {
		Data struct {
			ProcessID      string `json:"process_id"`
			Status         string `json:"status"`
			Message        string `json:"message"`
			TotalItems     int    `json:"total_items"`
			ProcessedItems int    `json:"processed_items"`
		} `json:"data"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &envelope); err != nil {
		t.Fatalf("json: %v body=%s", err, rec.Body.String())
	}
	if envelope.Data.ProcessID != jobID.String() {
		t.Fatalf("process_id=%q want %s", envelope.Data.ProcessID, jobID)
	}
	if envelope.Data.Status != "pending" {
		t.Fatalf("status=%q want pending", envelope.Data.Status)
	}
	if envelope.Data.TotalItems != 1 || envelope.Data.ProcessedItems != 0 {
		t.Fatalf("counts=%+v (processed_items must be 0 on start)", envelope.Data)
	}
	if enqueued != jobID {
		t.Fatalf("enqueued=%s", enqueued)
	}
	if len(sawEANs) != 1 || sawEANs[0] != "1234567890123" {
		t.Fatalf("eans=%v", sawEANs)
	}
	if strings.Contains(rec.Body.String(), `"meta"`) {
		t.Fatalf("start response should omit meta: %s", rec.Body.String())
	}
}

func TestHandleV1StartProcessUnauthorizedWithoutCompany(t *testing.T) {
	t.Parallel()
	s := &Server{}
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(`{"items":[{"ean":"1"}]}`))
	s.handleV1StartProcess(rec, req)
	if rec.Code != http.StatusUnauthorized {
		t.Fatalf("status=%d", rec.Code)
	}
	if !strings.Contains(rec.Body.String(), `"code":"unauthorized"`) {
		t.Fatalf("body=%s", rec.Body.String())
	}
}

func TestRouterV1ProductsProcessAuthUsesCodedError(t *testing.T) {
	t.Parallel()
	s := testAPIServer()
	h := s.Router()
	rec := httptest.NewRecorder()
	h.ServeHTTP(rec, httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(`{"items":[{"ean":"1"}]}`)))
	if rec.Code != http.StatusUnauthorized {
		t.Fatalf("status=%d", rec.Code)
	}
	if !strings.Contains(rec.Body.String(), `"code":"unauthorized"`) || !strings.Contains(rec.Body.String(), `"message":"Unauthorized"`) {
		t.Fatalf("want coded envelope, got %s", rec.Body.String())
	}
}

func TestHandleV1StartProcessRejectsInvalidProcessingTypes(t *testing.T) {
	t.Parallel()
	s := &Server{}
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	ctx = context.WithValue(ctx, ctxUserID, uuid.MustParse("22222222-2222-2222-2222-222222222222"))

	rec := httptest.NewRecorder()
	body := `{"processing_types":["both"],"items":[{"ean":"1234567890123"}]}`
	req := httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(body))
	req = req.WithContext(ctx)
	s.handleV1StartProcess(rec, req)
	if rec.Code != http.StatusBadRequest {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	if !strings.Contains(rec.Body.String(), "validation_error") {
		t.Fatalf("body=%s", rec.Body.String())
	}
}

func TestHandleV1StartProcessRejectsTooManyRawIDs(t *testing.T) {
	// Not parallel: mutates process-wide SetTestStartProductCap.
	processing.SetTestStartProductCap(2)
	t.Cleanup(func() { processing.SetTestStartProductCap(0) })

	s := &Server{
		testEnsureRawV1Items: func(context.Context, uuid.UUID, []catalog.V1ProcessItem) ([]uuid.UUID, []catalog.EnsureRawResult, []string, error) {
			t.Fatal("ensureRaw must not run for oversized payloads")
			return nil, nil, nil, nil
		},
		testStartJobs: func(context.Context, uuid.UUID, uuid.UUID, []uuid.UUID, string) ([]processing.Job, error) {
			t.Fatal("startJobs must not run for oversized payloads")
			return nil, nil
		},
	}
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	ctx = context.WithValue(ctx, ctxUserID, uuid.MustParse("22222222-2222-2222-2222-222222222222"))

	body := fmt.Sprintf(
		`{"processing_type":"full","raw_product_ids":[%q,%q,%q]}`,
		uuid.New().String(), uuid.New().String(), uuid.New().String(),
	)
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(body))
	req = req.WithContext(ctx)
	s.handleV1StartProcess(rec, req)
	if rec.Code != http.StatusBadRequest {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	if !strings.Contains(rec.Body.String(), "too many products") {
		t.Fatalf("body=%s", rec.Body.String())
	}
}

func TestHandleV1GetProcessPassesCompanyScope(t *testing.T) {
	t.Parallel()
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	jobID := uuid.MustParse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
	var sawCompany, sawJob uuid.UUID
	s := &Server{
		testGetJob: func(_ context.Context, companyID, id uuid.UUID) (processing.Job, error) {
			sawCompany = companyID
			sawJob = id
			return processing.Job{}, errors.New("not found")
		},
	}
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/api/v1/products/process/"+jobID.String(), nil)
	rctx := chi.NewRouteContext()
	rctx.URLParams.Add("id", jobID.String())
	req = req.WithContext(context.WithValue(ctx, chi.RouteCtxKey, rctx))
	s.handleV1GetProcess(rec, req)
	if rec.Code != http.StatusNotFound {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	if sawCompany != cid || sawJob != jobID {
		t.Fatalf("scoped call company=%s job=%s", sawCompany, sawJob)
	}
}

func TestHandleV1GetProcessCompletedIncludesProcessedItems(t *testing.T) {
	t.Parallel()
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	jobID := uuid.MustParse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
	productID := "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
	s := &Server{
		testGetJob: func(_ context.Context, companyID, id uuid.UUID) (processing.Job, error) {
			if companyID != cid || id != jobID {
				t.Fatalf("scoped call company=%s job=%s", companyID, id)
			}
			return processing.Job{
				ID:             jobID,
				CompanyID:      cid,
				Status:         "completed",
				ProcessingType: "full",
				TotalProducts:  1,
			}, nil
		},
		testLoadV1ProcessJobItems: func(_ context.Context, companyID, id uuid.UUID, processingType string) ([]processing.V1ProcessJobItem, error) {
			if companyID != cid || id != jobID || processingType != "full" {
				t.Fatalf("load scope company=%s job=%s type=%s", companyID, id, processingType)
			}
			return []processing.V1ProcessJobItem{{
				"ean":    "0123456789012",
				"id":     productID,
				"status": "processed",
				"title":  "Acme Widget",
			}}, nil
		},
	}
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/api/v1/products/process/"+jobID.String(), nil)
	rctx := chi.NewRouteContext()
	rctx.URLParams.Add("id", jobID.String())
	req = req.WithContext(context.WithValue(ctx, chi.RouteCtxKey, rctx))
	s.handleV1GetProcess(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	var body struct {
		Data map[string]any `json:"data"`
	}
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatal(err)
	}
	if body.Data["status"] != "COMPLETED" {
		t.Fatalf("status=%v", body.Data["status"])
	}
	if body.Data["total_items"].(float64) != 1 {
		t.Fatalf("total_items=%v", body.Data["total_items"])
	}
	items, ok := body.Data["items"].([]any)
	if !ok || len(items) != 1 {
		t.Fatalf("items=%v", body.Data["items"])
	}
	item, ok := items[0].(map[string]any)
	if !ok {
		t.Fatalf("item=%T", items[0])
	}
	if item["status"] != "processed" || item["id"] != productID || item["ean"] != "0123456789012" {
		t.Fatalf("item=%v", item)
	}
	if _, ok := body.Data["processed_at"]; !ok {
		t.Fatalf("missing processed_at: %v", body.Data)
	}
}

func TestHandleGetProcessingJobCompletedIncludesItems(t *testing.T) {
	t.Parallel()
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	jobID := uuid.MustParse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
	s := &Server{
		testGetJob: func(_ context.Context, companyID, id uuid.UUID) (processing.Job, error) {
			return processing.Job{
				ID:             jobID,
				CompanyID:      companyID,
				Status:         "completed",
				ProcessingType: "full",
				TotalProducts:  1,
			}, nil
		},
		testLoadV1ProcessJobItems: func(context.Context, uuid.UUID, uuid.UUID, string) ([]processing.V1ProcessJobItem, error) {
			return []processing.V1ProcessJobItem{{
				"ean": "1", "id": "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb", "status": "processed", "title": "T",
			}}, nil
		},
	}
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/api/v1/process/"+jobID.String(), nil)
	rctx := chi.NewRouteContext()
	rctx.URLParams.Add("id", jobID.String())
	req = req.WithContext(context.WithValue(ctx, chi.RouteCtxKey, rctx))
	s.handleGetProcessingJob(rec, req)
	if rec.Code != http.StatusOK {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
	var body map[string]any
	if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
		t.Fatal(err)
	}
	if body["status"] != "completed" {
		t.Fatalf("status=%v", body["status"])
	}
	if body["total_items"].(float64) != 1 {
		t.Fatalf("total_items=%v", body["total_items"])
	}
	items, ok := body["items"].([]any)
	if !ok || len(items) != 1 {
		t.Fatalf("items=%v", body["items"])
	}
}

func TestHandleV1ListProcessJobsUnauthorizedWithoutCompany(t *testing.T) {
	t.Parallel()
	s := &Server{}
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodGet, "/api/v1/process", nil)
	s.handleV1ListProcessJobs(rec, req)
	if rec.Code != http.StatusUnauthorized {
		t.Fatalf("status=%d body=%s", rec.Code, rec.Body.String())
	}
}

func TestHandleV1StartProcessGatesBeforeEnsureRaw(t *testing.T) {
	t.Parallel()
	ensureCalled := false
	s := &Server{
		Billing: &billing.Service{}, // Pool nil → entitlements lookup fails before EnsureRaw
		testEnsureRawV1Items: func(context.Context, uuid.UUID, []catalog.V1ProcessItem) ([]uuid.UUID, []catalog.EnsureRawResult, []string, error) {
			ensureCalled = true
			return nil, nil, nil, nil
		},
	}
	cid := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	ctx := context.WithValue(context.Background(), ctxCompanyID, cid)
	ctx = context.WithValue(ctx, ctxUserID, uuid.MustParse("22222222-2222-2222-2222-222222222222"))
	body := `{"processing_type":"enhance","items":[{"ean":"1234567890123","title":"x"}]}`
	rec := httptest.NewRecorder()
	req := httptest.NewRequest(http.MethodPost, "/api/v1/products/process", strings.NewReader(body))
	req = req.WithContext(ctx)
	s.handleV1StartProcess(rec, req)
	if ensureCalled {
		t.Fatal("EnsureRaw must not run when billing gate fails")
	}
	if rec.Code == http.StatusOK || rec.Code == http.StatusCreated || rec.Code == http.StatusAccepted {
		t.Fatalf("expected gate failure, got %d %s", rec.Code, rec.Body.String())
	}
	var env map[string]any
	if err := json.Unmarshal(rec.Body.Bytes(), &env); err != nil {
		t.Fatalf("response json: %v body=%s", err, rec.Body.String())
	}
	if _, ok := env["error"]; !ok {
		if _, ok := env["code"]; !ok {
			t.Fatalf("expected error envelope, got %s", rec.Body.String())
		}
	}
}

func TestAssertV1ProcessGatesNilBilling(t *testing.T) {
	t.Parallel()
	s := &Server{}
	if err := s.assertV1ProcessGates(context.Background(), uuid.New(), "enhance", 2); err != nil {
		t.Fatalf("nil billing must no-op: %v", err)
	}
}