package assets_test

import (
	"context"
	"testing"

	"vibetree/internal/assets"
	"vibetree/internal/itemtypes"
	"vibetree/internal/models"
)

func TestQuantityFixedAtOneForUniqueTypes(t *testing.T) {
	ctx := context.Background()
	as, _, _ := testStores(t)

	a := &models.Asset{Name: "Laptop 1", ItemTypeID: itemTypeLaptop, StatusID: statusInUse, Quantity: 7}
	if err := as.Create(ctx, a, nil); err != nil {
		t.Fatalf("create: %v", err)
	}
	if a.Quantity != 1 {
		t.Fatalf("expected quantity forced to 1 for a unique item type, got %d", a.Quantity)
	}

	if _, err := as.AdjustQuantity(ctx, a.ID, 1); err != assets.ErrQuantityNotTracked {
		t.Fatalf("expected ErrQuantityNotTracked, got %v", err)
	}
}

func TestQuantityTrackedForNonUniqueTypes(t *testing.T) {
	ctx := context.Background()
	as, _, db := testStores(t)
	itStore := itemtypes.NewStore(db)

	cable := &models.ItemType{Name: "Cable", Enabled: true, IsUnique: false}
	if err := itStore.Create(ctx, cable); err != nil {
		t.Fatalf("create item type: %v", err)
	}

	a := &models.Asset{Name: "USB-A Cable", ItemTypeID: cable.ID, StatusID: statusInUse, Quantity: 10}
	if err := as.Create(ctx, a, nil); err != nil {
		t.Fatalf("create: %v", err)
	}
	if a.Quantity != 10 {
		t.Fatalf("expected quantity 10, got %d", a.Quantity)
	}

	updated, err := as.AdjustQuantity(ctx, a.ID, 5)
	if err != nil {
		t.Fatalf("adjust +5: %v", err)
	}
	if updated.Quantity != 15 {
		t.Fatalf("expected 15, got %d", updated.Quantity)
	}

	updated, err = as.AdjustQuantity(ctx, a.ID, -100)
	if err != nil {
		t.Fatalf("adjust -100: %v", err)
	}
	if updated.Quantity != 0 {
		t.Fatalf("expected quantity floored at 0, got %d", updated.Quantity)
	}
}

func TestItemTypeBecomingUniqueClampsExistingQuantities(t *testing.T) {
	ctx := context.Background()
	as, _, db := testStores(t)
	itStore := itemtypes.NewStore(db)

	cable := &models.ItemType{Name: "Cable", Enabled: true, IsUnique: false}
	if err := itStore.Create(ctx, cable); err != nil {
		t.Fatalf("create item type: %v", err)
	}
	a := &models.Asset{Name: "USB-A Cable", ItemTypeID: cable.ID, StatusID: statusInUse, Quantity: 20}
	if err := as.Create(ctx, a, nil); err != nil {
		t.Fatalf("create asset: %v", err)
	}

	cable.IsUnique = true
	if err := itStore.Update(ctx, cable); err != nil {
		t.Fatalf("update item type: %v", err)
	}

	got, err := as.Get(ctx, a.ID)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if got.Quantity != 1 {
		t.Fatalf("expected quantity clamped to 1 after type became unique, got %d", got.Quantity)
	}
}

func TestAssignUserChecksInAndOut(t *testing.T) {
	ctx := context.Background()
	as, _, _ := testStores(t)

	a := &models.Asset{Name: "Laptop 1", ItemTypeID: itemTypeLaptop, StatusID: statusInUse}
	if err := as.Create(ctx, a, nil); err != nil {
		t.Fatalf("create: %v", err)
	}

	userID := int64(1) // seeded admin
	if err := as.AssignUser(ctx, a.ID, &userID); err != nil {
		t.Fatalf("assign user: %v", err)
	}
	got, err := as.Get(ctx, a.ID)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if got.AssignedUserID == nil || *got.AssignedUserID != userID {
		t.Fatalf("expected asset checked out to user %d, got %+v", userID, got.AssignedUserID)
	}

	if err := as.AssignUser(ctx, a.ID, nil); err != nil {
		t.Fatalf("check in: %v", err)
	}
	got, err = as.Get(ctx, a.ID)
	if err != nil {
		t.Fatalf("get: %v", err)
	}
	if got.AssignedUserID != nil {
		t.Fatalf("expected asset checked in (unassigned), got %+v", got.AssignedUserID)
	}
}