package repository

import (
	"os"
	"testing"
	"time"

	"job-cheng-xing/model"
)

func setupSQLiteRepo(t *testing.T) *SQLiteRepo {
	t.Helper()
	dbPath := "/tmp/test_orders_" + t.Name() + ".db"
	repo, err := NewSQLiteRepo(dbPath)
	if err != nil {
		t.Fatalf("failed to create SQLite repo: %v", err)
	}
	t.Cleanup(func() {
		repo.Close()
		os.Remove(dbPath)
	})
	return repo
}

func TestSQLiteRepo_CreateAndFind(t *testing.T) {
	repo := setupSQLiteRepo(t)

	order := &model.Order{
		ID:          "ord_001",
		Status:      model.StatusPending,
		ServiceTime: time.Now(),
		Duration:    120,
		Address:     "北京朝阳",
		CreatedAt:   time.Now(),
		UpdatedAt:   time.Now(),
	}

	err := repo.Create(order)
	if err != nil {
		t.Fatalf("Create failed: %v", err)
	}

	found, err := repo.FindByID("ord_001")
	if err != nil {
		t.Fatalf("FindByID failed: %v", err)
	}
	if found.ID != "ord_001" {
		t.Errorf("expected ord_001, got %s", found.ID)
	}
	if found.Address != "北京朝阳" {
		t.Errorf("expected 北京朝阳, got %s", found.Address)
	}
}

func TestSQLiteRepo_Update_CAS(t *testing.T) {
	repo := setupSQLiteRepo(t)

	order := &model.Order{
		ID:          "ord_001",
		Status:      model.StatusPending,
		ServiceTime: time.Now(),
		Duration:    120,
		Address:     "北京朝阳",
		CreatedAt:   time.Now(),
		UpdatedAt:   time.Now(),
	}
	repo.Create(order)

	pid := "prov_001"
	newOrder := &model.Order{
		Status:     model.StatusAccepted,
		ProviderID: &pid,
		UpdatedAt:  time.Now(),
	}
	err := repo.Update("ord_001", model.StatusPending, newOrder)
	if err != nil {
		t.Fatalf("Update failed: %v", err)
	}

	found, _ := repo.FindByID("ord_001")
	if found.Status != model.StatusAccepted {
		t.Errorf("expected accepted, got %s", found.Status)
	}
}

func TestSQLiteRepo_Update_CAS_Fail(t *testing.T) {
	repo := setupSQLiteRepo(t)

	order := &model.Order{
		ID:          "ord_001",
		Status:      model.StatusAccepted,
		ServiceTime: time.Now(),
		Duration:    120,
		Address:     "北京朝阳",
		CreatedAt:   time.Now(),
		UpdatedAt:   time.Now(),
	}
	repo.Create(order)

	newOrder := &model.Order{Status: model.StatusCanceled}
	err := repo.Update("ord_001", model.StatusPending, newOrder)
	if err != model.ErrStatusConflict {
		t.Errorf("expected ErrStatusConflict, got %v", err)
	}
}

func TestSQLiteRepo_FindByID_NotFound(t *testing.T) {
	repo := setupSQLiteRepo(t)

	_, err := repo.FindByID("nonexistent")
	if err != model.ErrNotFound {
		t.Errorf("expected ErrNotFound, got %v", err)
	}
}