package openai

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"mime/multipart"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/go-chi/chi/v5"

	"ds2api/internal/auth"
	dsclient "ds2api/internal/deepseek/client"
)

type managedFilesAuthStub struct{}

func (managedFilesAuthStub) Determine(_ *http.Request) (*auth.RequestAuth, error) {
	return &auth.RequestAuth{
		UseConfigToken: true,
		DeepSeekToken:  "managed-token",
		CallerID:       "caller:test",
		AccountID:      "acct-123",
		TriedAccounts:  map[string]bool{},
	}, nil
}

func (managedFilesAuthStub) DetermineCaller(_ *http.Request) (*auth.RequestAuth, error) {
	return &auth.RequestAuth{
		UseConfigToken: true,
		DeepSeekToken:  "managed-token",
		CallerID:       "caller:test",
		AccountID:      "acct-123",
		TriedAccounts:  map[string]bool{},
	}, nil
}

func (managedFilesAuthStub) Release(_ *auth.RequestAuth) {}

type filesRouteDSStub struct {
	lastReq dsclient.UploadFileRequest
	upload  *dsclient.UploadFileResult
	fetched *dsclient.UploadFileResult
	err     error
}

func (m *filesRouteDSStub) CreateSession(_ context.Context, _ *auth.RequestAuth, _ int) (string, error) {
	return "", nil
}

func (m *filesRouteDSStub) GetPow(_ context.Context, _ *auth.RequestAuth, _ int) (string, error) {
	return "", nil
}

func (m *filesRouteDSStub) UploadFile(_ context.Context, _ *auth.RequestAuth, req dsclient.UploadFileRequest, _ int) (*dsclient.UploadFileResult, error) {
	m.lastReq = req
	if m.err != nil {
		return nil, m.err
	}
	if m.upload != nil {
		return m.upload, nil
	}
	return &dsclient.UploadFileResult{ID: "file-123", Filename: req.Filename, Bytes: int64(len(req.Data)), Purpose: req.Purpose, Status: "uploaded"}, nil
}

func (m *filesRouteDSStub) FetchUploadedFile(_ context.Context, _ *auth.RequestAuth, fileID string) (*dsclient.UploadFileResult, error) {
	if m.err != nil {
		return nil, m.err
	}
	if m.fetched != nil {
		return m.fetched, nil
	}
	return &dsclient.UploadFileResult{ID: fileID, Filename: "notes.txt", Bytes: 11, Purpose: "assistants", Status: "processed"}, nil
}

func (m *filesRouteDSStub) CallCompletion(_ context.Context, _ *auth.RequestAuth, _ map[string]any, _ string, _ int) (*http.Response, error) {
	return nil, errors.New("not implemented")
}

func (m *filesRouteDSStub) DeleteSessionForToken(_ context.Context, _ string, _ string) (*dsclient.DeleteSessionResult, error) {
	return &dsclient.DeleteSessionResult{Success: true}, nil
}

func (m *filesRouteDSStub) DeleteAllSessionsForToken(_ context.Context, _ string) error {
	return nil
}

func newMultipartUploadRequest(t *testing.T, purpose string, filename string, data []byte, model string) *http.Request {
	t.Helper()
	var body bytes.Buffer
	writer := multipart.NewWriter(&body)
	if purpose != "" {
		if err := writer.WriteField("purpose", purpose); err != nil {
			t.Fatalf("write purpose failed: %v", err)
		}
	}
	if model != "" {
		if err := writer.WriteField("model", model); err != nil {
			t.Fatalf("write model failed: %v", err)
		}
	}
	part, err := writer.CreateFormFile("file", filename)
	if err != nil {
		t.Fatalf("create form file failed: %v", err)
	}
	if _, err := part.Write(data); err != nil {
		t.Fatalf("write file failed: %v", err)
	}
	if err := writer.Close(); err != nil {
		t.Fatalf("close writer failed: %v", err)
	}
	req := httptest.NewRequest(http.MethodPost, "/v1/files", &body)
	req.Header.Set("Authorization", "Bearer direct-token")
	req.Header.Set("Content-Type", writer.FormDataContentType())
	return req
}

func TestFilesRouteUploadSuccess(t *testing.T) {
	ds := &filesRouteDSStub{}
	h := &openAITestSurface{Store: mockOpenAIConfig{}, Auth: streamStatusAuthStub{}, DS: ds}
	r := chi.NewRouter()
	registerOpenAITestRoutes(r, h)

	req := newMultipartUploadRequest(t, "assistants", "notes.txt", []byte("hello world"), "deepseek-v4-vision")
	rec := httptest.NewRecorder()
	r.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
	}
	if ds.lastReq.Filename != "notes.txt" {
		t.Fatalf("expected filename notes.txt, got %q", ds.lastReq.Filename)
	}
	if ds.lastReq.Purpose != "assistants" {
		t.Fatalf("expected purpose assistants, got %q", ds.lastReq.Purpose)
	}
	if ds.lastReq.ModelType != "vision" {
		t.Fatalf("expected vision model type, got %q", ds.lastReq.ModelType)
	}
	if string(ds.lastReq.Data) != "hello world" {
		t.Fatalf("unexpected uploaded data: %q", string(ds.lastReq.Data))
	}
	var out map[string]any
	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
		t.Fatalf("decode response failed: %v body=%s", err, rec.Body.String())
	}
	if out["object"] != "file" {
		t.Fatalf("expected file object, got %#v", out)
	}
	if out["id"] != "file-123" {
		t.Fatalf("expected file id file-123, got %#v", out["id"])
	}
	if out["filename"] != "notes.txt" {
		t.Fatalf("expected filename notes.txt, got %#v", out["filename"])
	}
}

func TestFilesRouteUploadIncludesAccountIDForManagedAccount(t *testing.T) {
	ds := &filesRouteDSStub{}
	h := &openAITestSurface{Store: mockOpenAIConfig{}, Auth: managedFilesAuthStub{}, DS: ds}
	r := chi.NewRouter()
	registerOpenAITestRoutes(r, h)

	req := newMultipartUploadRequest(t, "assistants", "notes.txt", []byte("hello world"), "deepseek-v4-vision")
	rec := httptest.NewRecorder()
	r.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
	}
	var out map[string]any
	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
		t.Fatalf("decode response failed: %v body=%s", err, rec.Body.String())
	}
	if out["account_id"] != "acct-123" {
		t.Fatalf("expected account_id acct-123, got %#v", out["account_id"])
	}
}

func TestFilesRouteRetrieveSuccess(t *testing.T) {
	ds := &filesRouteDSStub{fetched: &dsclient.UploadFileResult{
		ID:       "file-123",
		Filename: "notes.txt",
		Bytes:    11,
		Purpose:  "assistants",
		Status:   "processed",
	}}
	h := &openAITestSurface{Store: mockOpenAIConfig{}, Auth: managedFilesAuthStub{}, DS: ds}
	r := chi.NewRouter()
	registerOpenAITestRoutes(r, h)

	req := httptest.NewRequest(http.MethodGet, "/v1/files/file-123", nil)
	req.Header.Set("Authorization", "Bearer direct-token")
	rec := httptest.NewRecorder()
	r.ServeHTTP(rec, req)

	if rec.Code != http.StatusOK {
		t.Fatalf("expected 200, got %d body=%s", rec.Code, rec.Body.String())
	}
	var out map[string]any
	if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil {
		t.Fatalf("decode response failed: %v body=%s", err, rec.Body.String())
	}
	if out["id"] != "file-123" || out["filename"] != "notes.txt" || out["status"] != "processed" {
		t.Fatalf("unexpected file object: %#v", out)
	}
	if out["account_id"] != "acct-123" {
		t.Fatalf("expected account_id acct-123, got %#v", out["account_id"])
	}
}

func TestFilesRouteRetrieveNotFound(t *testing.T) {
	ds := &filesRouteDSStub{err: dsclient.ErrUploadFileNotFound}
	h := &openAITestSurface{Store: mockOpenAIConfig{}, Auth: streamStatusAuthStub{}, DS: ds}
	r := chi.NewRouter()
	registerOpenAITestRoutes(r, h)

	req := httptest.NewRequest(http.MethodGet, "/v1/files/missing-file", nil)
	req.Header.Set("Authorization", "Bearer direct-token")
	rec := httptest.NewRecorder()
	r.ServeHTTP(rec, req)

	if rec.Code != http.StatusNotFound {
		t.Fatalf("expected 404, got %d body=%s", rec.Code, rec.Body.String())
	}
}

func TestFilesRouteRejectsNonMultipart(t *testing.T) {
	h := &openAITestSurface{Store: mockOpenAIConfig{}, Auth: streamStatusAuthStub{}, DS: &filesRouteDSStub{}}
	r := chi.NewRouter()
	registerOpenAITestRoutes(r, h)

	req := httptest.NewRequest(http.MethodPost, "/v1/files", bytes.NewBufferString(`{"purpose":"assistants"}`))
	req.Header.Set("Authorization", "Bearer direct-token")
	req.Header.Set("Content-Type", "application/json")
	rec := httptest.NewRecorder()
	r.ServeHTTP(rec, req)

	if rec.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
	}
}

func TestFilesRouteRequiresFileField(t *testing.T) {
	h := &openAITestSurface{Store: mockOpenAIConfig{}, Auth: streamStatusAuthStub{}, DS: &filesRouteDSStub{}}
	r := chi.NewRouter()
	registerOpenAITestRoutes(r, h)

	var body bytes.Buffer
	writer := multipart.NewWriter(&body)
	if err := writer.WriteField("purpose", "assistants"); err != nil {
		t.Fatalf("write field failed: %v", err)
	}
	if err := writer.Close(); err != nil {
		t.Fatalf("close writer failed: %v", err)
	}
	req := httptest.NewRequest(http.MethodPost, "/v1/files", &body)
	req.Header.Set("Authorization", "Bearer direct-token")
	req.Header.Set("Content-Type", writer.FormDataContentType())
	rec := httptest.NewRecorder()
	r.ServeHTTP(rec, req)

	if rec.Code != http.StatusBadRequest {
		t.Fatalf("expected 400, got %d body=%s", rec.Code, rec.Body.String())
	}
}