package application

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"reflect"
	"strings"
	"testing"

	"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/assets"
	"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/billing"
	"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/providers"
	"git.nianxx.cn/wangxuming/NianAIGC/backend/internal/settings"
)

func TestDefaultSettingsServiceAppliesProviderSettingsWithoutRestart(t *testing.T) {
	path := filepath.Join(t.TempDir(), ".env.local")
	key := "IMAGE_GENERATE_ENGINE"
	service := defaultSettingsService(func(name string) string {
		if name == "ZHINIAN_SETTINGS_FILE" {
			return path
		}
		return ""
	})
	value, err := service.Save(context.Background(), map[string]any{key: "evolink"})
	if err != nil {
		t.Fatal(err)
	}
	payload, ok := value.(settings.Payload)
	if !ok || payload.RestartRequired {
		t.Fatalf("payload=%#v", value)
	}
}

func TestBillingAccountAndSettingsUseOneRuntimeSource(t *testing.T) {
	path := filepath.Join(t.TempDir(), ".env.local")
	if err := os.WriteFile(path, []byte("ZHINIAN_BILLING_ACCOUNT_NAME=Original\nZHINIAN_BILLING_ACCOUNT_BANK=Old Bank\n"), 0o600); err != nil {
		t.Fatal(err)
	}
	service := defaultSettingsService(func(name string) string {
		if name == "ZHINIAN_SETTINGS_FILE" {
			return path
		}
		return ""
	})
	store := settingsBillingAccountStore{service: service}
	if err := store.Save(context.Background(), billing.AccountConfig{AccountName: "Updated", BankName: "New Bank", AccountNumber: "123", Contact: "Ops"}); err != nil {
		t.Fatal(err)
	}
	loaded, err := store.Load(context.Background())
	if err != nil || loaded.AccountName != "Updated" || loaded.BankName != "New Bank" || loaded.AccountNumber != "123" || loaded.Contact != "Ops" {
		t.Fatalf("loaded=%#v err=%v", loaded, err)
	}
	payload, err := service.Get(context.Background())
	if err != nil || fieldValueFromSettings(t, payload, "ZHINIAN_BILLING_ACCOUNT_NAME") != "Updated" {
		t.Fatalf("settings payload=%#v err=%v", payload, err)
	}
}

func fieldValueFromSettings(t *testing.T, value any, key string) string {
	t.Helper()
	payload := value.(settings.Payload)
	for _, group := range payload.Groups {
		for _, field := range group.Fields {
			if field.Key == key {
				return field.Value
			}
		}
	}
	t.Fatalf("settings field %s not found", key)
	return ""
}

func TestRuntimeHealthDetailsMatchTypeScriptDefaultsAndConfiguredModes(t *testing.T) {
	values := map[string]string{
		"VOLCENGINE_ACCESS_KEY_ID":     "access",
		"VOLCENGINE_SECRET_ACCESS_KEY": "secret",
		"SEEDANCE_API_KEY":             "seedance-key",
		"VIDEO_GENERATE_ENGINE":        "seedance",
		"ZHINIAN_AUTH_REQUIRED":        "true",
		"ZHINIAN_AUTH_SESSION_SECRET":  "session-secret",
	}
	details := runtimeHealthDetails(func(name string) string { return values[name] })
	if details.VisualAPIMode != "volcengine" || details.EvolinkMode != "missing" || details.SeedanceMode != "seedance" || details.BailianMode != "missing" || details.AuthMode != "configured" {
		t.Fatalf("details = %+v", details)
	}
	if len(details.Capabilities) != 2 {
		t.Fatalf("capabilities = %#v, want image and Seedance", details.Capabilities)
	}
	image := details.Capabilities[0].(map[string]any)
	video := details.Capabilities[1].(map[string]any)
	if image["id"] != "image.generate" || image["engineLabel"] != "即梦" || video["id"] != "video.generate" || video["engineLabel"] != "Seedance" {
		t.Fatalf("capabilities = %#v", details.Capabilities)
	}
}

func TestRuntimeProviderJobBuilderRefreshesDatabaseSettings(t *testing.T) {
	settingsPath := filepath.Join(t.TempDir(), ".env.local")
	fallback := func(name string) string {
		if name == "ZHINIAN_SETTINGS_FILE" {
			return settingsPath
		}
		return ""
	}
	repository := &applicationRuntimeSettingsRepository{values: map[string]string{
		"EVOLINK_API_KEY":       "evolink-secret",
		"EVOLINK_IMAGE_MODEL":   "database-image-model",
		"EVOLINK_IMAGE_QUALITY": "high",
		"IMAGE_GENERATE_ENGINE": "evolink",
	}}
	service := databaseSettingsService(fallback, repository)
	builder := runtimeProviderJobBuilder{fallback: fallback, settings: service, enforceAvailability: true}
	command, err := builder.Build(context.Background(), "owner", "", "image.generate", "", map[string]any{"prompt": "draw"})
	if err != nil {
		t.Fatal(err)
	}
	var request providers.Request
	if err := json.Unmarshal(command.Job.RequestPayload, &request); err != nil {
		t.Fatal(err)
	}
	if command.Job.Provider != "evolink" || command.Job.ReqKey != "database-image-model" || request.Settings["quality"] != "high" {
		t.Fatalf("job=%#v request=%#v", command.Job, request)
	}
	repository.values = map[string]string{
		"BAILIAN_API_KEY":       "bailian-secret",
		"BAILIAN_IMAGE_MODEL":   "database-bailian-model",
		"IMAGE_GENERATE_ENGINE": "bailian",
	}
	command, err = builder.Build(context.Background(), "owner", "", "image.generate", "", map[string]any{"prompt": "draw again"})
	if err != nil {
		t.Fatal(err)
	}
	if command.Job.Provider != "bailian" || command.Job.ReqKey != "database-bailian-model" {
		t.Fatalf("refreshed job=%#v", command.Job)
	}
}

func TestRuntimeProviderResolverUsesLatestDatabaseCredential(t *testing.T) {
	var authorizations []string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
		authorizations = append(authorizations, request.Header.Get("Authorization"))
		w.Header().Set("Content-Type", "application/json")
		_, _ = w.Write([]byte(`{"id":"task-1","status":"queued"}`))
	}))
	defer server.Close()
	settingsPath := filepath.Join(t.TempDir(), ".env.local")
	fallback := func(name string) string {
		if name == "ZHINIAN_SETTINGS_FILE" {
			return settingsPath
		}
		return ""
	}
	repository := &applicationRuntimeSettingsRepository{values: map[string]string{
		"EVOLINK_API_KEY":  "database-secret-1",
		"EVOLINK_BASE_URL": server.URL,
	}}
	service := databaseSettingsService(fallback, repository)
	resolver := newRuntimeProviderResolver(fallback, service)
	adapter, err := resolver.Resolve(context.Background(), "evolink")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := adapter.Submit(context.Background(), providers.Request{Capability: "image.generate", Prompt: "draw"}); err != nil {
		t.Fatal(err)
	}
	repository.values["EVOLINK_API_KEY"] = "database-secret-2"
	adapter, err = resolver.Resolve(context.Background(), "evolink")
	if err != nil {
		t.Fatal(err)
	}
	if _, err := adapter.Submit(context.Background(), providers.Request{Capability: "image.generate", Prompt: "draw again"}); err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(authorizations, []string{"Bearer database-secret-1", "Bearer database-secret-2"}) {
		t.Fatalf("authorizations=%#v", authorizations)
	}
}

func TestRuntimeHealthDetailsReportConfiguredProvidersAndImageEngine(t *testing.T) {
	values := map[string]string{
		"IMAGE_GENERATE_ENGINE": "bailian",
		"BAILIAN_API_KEY":       "bailian-key",
	}
	details := runtimeHealthDetails(func(name string) string { return values[name] })
	if details.VisualAPIMode != "missing" || details.EvolinkMode != "missing" || details.SeedanceMode != "missing" || details.BailianMode != "bailian" || details.AuthMode != "disabled" {
		t.Fatalf("details = %+v", details)
	}
	image := details.Capabilities[0].(map[string]any)
	if image["engine"] != "bailian" || image["engineLabel"] != "阿里云百炼" || image["reqKey"] != "wan2.7-image-pro" {
		t.Fatalf("image capability = %#v", image)
	}
}

func TestProviderUnavailableMessagesIdentifyOnlyMissingCredentials(t *testing.T) {
	values := map[string]string{
		"VOLCENGINE_ACCESS_KEY_ID":     "access",
		"VOLCENGINE_SECRET_ACCESS_KEY": "secret",
		"EVOLINK_API_KEY":              "evolink",
		"BAILIAN_API_KEY":              "bailian",
	}
	missing := providerUnavailableMessages(func(name string) string { return values[name] })
	if len(missing) != 1 || !strings.Contains(missing["seedance"], "SEEDANCE_API_KEY") {
		t.Fatalf("missing = %#v", missing)
	}
}

func TestProviderTargetsNeverSelectRemovedProvider(t *testing.T) {
	getenv := func(string) string { return "" }
	for engine, target := range providerImageTargets(getenv) {
		if target.Provider == "mock" {
			t.Fatalf("image engine %s selected removed provider", engine)
		}
	}
	for engine, target := range providerVideoTargets(getenv) {
		if target.Provider == "mock" {
			t.Fatalf("video engine %s selected removed provider", engine)
		}
	}
}

func TestCapabilitySummaryMatchesConfiguredDefaultVideoEngine(t *testing.T) {
	for _, test := range []struct {
		name, engine, wantEngine, wantProvider, wantModel string
	}{
		{name: "Bailian default", engine: "", wantEngine: "bailian", wantProvider: "bailian", wantModel: "wan2.7-i2v-2026-04-25"},
		{name: "Seedance configured", engine: "seedance", wantEngine: "seedance", wantProvider: "seedance", wantModel: "doubao-seedance-2-0-260128"},
	} {
		t.Run(test.name, func(t *testing.T) {
			values := map[string]string{"VIDEO_GENERATE_ENGINE": test.engine}
			value, err := capabilitySummary(func(name string) string { return values[name] })(context.Background())
			if err != nil {
				t.Fatal(err)
			}
			capabilities := value.([]any)
			video := capabilities[1].(map[string]any)
			if video["engine"] != test.wantEngine || video["provider"] != test.wantProvider || video["reqKey"] != test.wantModel {
				t.Fatalf("video capability = %#v", video)
			}
		})
	}
}

func TestRemoteAssetMaximumDefaultsToTwentyMiB(t *testing.T) {
	getenv := func(string) string { return "" }
	if got := remoteAssetMaxBytes(getenv); got != 20<<20 {
		t.Fatalf("remote asset maximum = %d, want %d", got, int64(20<<20))
	}
	getenv = func(string) string { return "3145728" }
	if got := remoteAssetMaxBytes(getenv); got != 3<<20 {
		t.Fatalf("configured remote asset maximum = %d, want %d", got, int64(3<<20))
	}
}

func TestPrefixedBlobStoreKeepsApplicationStoragePathStable(t *testing.T) {
	inner := &recordingBlobStore{}
	store := prefixedBlobStore{prefix: "tenant-prefix", store: inner}
	stored, err := store.Put(context.Background(), "uploads/day/file.png", bytes.NewReader([]byte("x")), 1, "image/png")
	if err != nil {
		t.Fatal(err)
	}
	if stored.Key != "uploads/day/file.png" || inner.putKey != "tenant-prefix/uploads/day/file.png" {
		t.Fatalf("stored=%#v inner=%q", stored, inner.putKey)
	}
	_, _ = store.Read(context.Background(), stored.Key)
	_ = store.Delete(context.Background(), stored.Key)
	if !reflect.DeepEqual([]string{inner.readKey, inner.deleteKey}, []string{"tenant-prefix/uploads/day/file.png", "tenant-prefix/uploads/day/file.png"}) {
		t.Fatalf("read/delete=%q/%q", inner.readKey, inner.deleteKey)
	}
}

type recordingBlobStore struct{ putKey, readKey, deleteKey string }

type applicationRuntimeSettingsRepository struct{ values map[string]string }

func (repository *applicationRuntimeSettingsRepository) LoadRuntimeSettings(context.Context, []string) (map[string]string, error) {
	values := map[string]string{}
	for key, value := range repository.values {
		values[key] = value
	}
	return values, nil
}

func (repository *applicationRuntimeSettingsRepository) SaveRuntimeSettings(_ context.Context, values map[string]string) error {
	if repository.values == nil {
		repository.values = map[string]string{}
	}
	for key, value := range values {
		repository.values[key] = value
	}
	return nil
}

func (s *recordingBlobStore) Put(_ context.Context, key string, _ io.Reader, _ int64, _ string) (assets.StoredObject, error) {
	s.putKey = key
	return assets.StoredObject{Key: key, URL: "https://cdn.example/" + key}, nil
}
func (s *recordingBlobStore) Read(_ context.Context, key string) (assets.Blob, error) {
	s.readKey = key
	return assets.Blob{Body: io.NopCloser(bytes.NewReader(nil))}, nil
}
func (s *recordingBlobStore) Delete(_ context.Context, key string) error {
	s.deleteKey = key
	return nil
}