package integration

import (
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

// ==============================================================================
// Collection DML Tests with go-salesforce
// ==============================================================================

// TestGoSF_InsertCollection tests batch insert via go-salesforce library
func TestGoSF_InsertCollection(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test")
	}

	sf := newGoSFClient(t)
	if sf == nil {
		t.Skip("go-salesforce client not available")
	}

	accounts := []Account{
		{Name: "GoSF Collection Test 1"},
		{Name: "GoSF Collection Test 2"},
		{Name: "GoSF Collection Test 3"},
	}

	results, err := sf.InsertCollection("Account", accounts, 200)
	t.Logf("InsertCollection results: %d, error: %v", len(results.Results), err)

	require.NoError(t, err, "InsertCollection should succeed")
	assert.Equal(t, 3, len(results.Results), "Should return 3 results")
	for _, r := range results.Results {
		assert.True(t, r.Success, "Each insert should succeed")
		assert.NotEmpty(t, r.Id, "Each result should have an ID")
	}
}

// TestGoSF_UpdateCollection tests batch update via go-salesforce library
func TestGoSF_UpdateCollection(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test")
	}

	sf := newGoSFClient(t)
	if sf == nil {
		t.Skip("go-salesforce client not available")
	}

	// First create records
	accounts := []Account{
		{Name: "GoSF Update Collection 1"},
		{Name: "GoSF Update Collection 2"},
	}

	insertResults, err := sf.InsertCollection("Account", accounts, 200)
	if err != nil {
		t.Skipf("Could not create test records: %v", err)
	}

	// Update the records
	for i, r := range insertResults.Results {
		accounts[i].Id = r.Id
		accounts[i].Name = "Updated " + accounts[i].Name
	}

	results, err := sf.UpdateCollection("Account", accounts, 200)
	t.Logf("UpdateCollection error: %v", err)

	if err == nil {
		assert.Equal(t, 2, len(results.Results))
	}
}

// TestGoSF_DeleteCollection tests batch delete via go-salesforce library
func TestGoSF_DeleteCollection(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test")
	}

	sf := newGoSFClient(t)
	if sf == nil {
		t.Skip("go-salesforce client not available")
	}

	// First create records
	accounts := []Account{
		{Name: "GoSF Delete Collection 1"},
		{Name: "GoSF Delete Collection 2"},
	}

	insertResults, err := sf.InsertCollection("Account", accounts, 200)
	if err != nil {
		t.Skipf("Could not create test records: %v", err)
	}

	// Delete the records
	for i, r := range insertResults.Results {
		accounts[i].Id = r.Id
	}

	results, err := sf.DeleteCollection("Account", accounts, 200)
	t.Logf("DeleteCollection error: %v", err)

	if err == nil {
		assert.Equal(t, 2, len(results.Results))
	}
}

// ==============================================================================
// Composite Request Tests with go-salesforce
// ==============================================================================

// TestGoSF_InsertComposite tests composite insert via go-salesforce library
func TestGoSF_InsertComposite(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test")
	}

	sf := newGoSFClient(t)
	if sf == nil {
		t.Skip("go-salesforce client not available")
	}

	accounts := []Account{
		{Name: "GoSF Composite 1"},
		{Name: "GoSF Composite 2"},
	}

	results, err := sf.InsertComposite("Account", accounts, 1, false)
	t.Logf("InsertComposite results: %d, error: %v", len(results.Results), err)

	if err == nil {
		assert.Equal(t, 2, len(results.Results))
	}
}

// TestGoSF_UpdateComposite tests composite update via go-salesforce library
func TestGoSF_UpdateComposite(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test")
	}

	sf := newGoSFClient(t)
	if sf == nil {
		t.Skip("go-salesforce client not available")
	}

	// First create records
	accounts := []Account{
		{Name: "GoSF Composite Update 1"},
	}

	insertResults, err := sf.InsertComposite("Account", accounts, 1, false)
	if err != nil {
		t.Skipf("Could not create test records: %v", err)
	}

	// Update
	for i, r := range insertResults.Results {
		accounts[i].Id = r.Id
		accounts[i].Name = "Updated " + accounts[i].Name
	}

	results, err := sf.UpdateComposite("Account", accounts, 1, false)
	t.Logf("UpdateComposite error: %v", err)

	if err == nil {
		assert.Equal(t, 1, len(results.Results))
	}
}

// TestGoSF_DeleteComposite tests composite delete via go-salesforce library
func TestGoSF_DeleteComposite(t *testing.T) {
	if testing.Short() {
		t.Skip("Skipping integration test")
	}

	sf := newGoSFClient(t)
	if sf == nil {
		t.Skip("go-salesforce client not available")
	}

	// First create records
	accounts := []Account{
		{Name: "GoSF Composite Delete 1"},
	}

	insertResults, err := sf.InsertComposite("Account", accounts, 1, false)
	if err != nil {
		t.Skipf("Could not create test records: %v", err)
	}

	// Delete
	for i, r := range insertResults.Results {
		accounts[i].Id = r.Id
	}

	results, err := sf.DeleteComposite("Account", accounts, 1, false)
	t.Logf("DeleteComposite error: %v", err)

	if err == nil {
		assert.Equal(t, 1, len(results.Results))
	}
}