package tests

import (
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"net/http/httptest"
	"testing"

	"github.com/gin-gonic/gin"
	"github.com/starfleetcptn/gomft/internal/api"
	"github.com/starfleetcptn/gomft/internal/db"
	"github.com/starfleetcptn/gomft/internal/testutils"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func setupStorageProviderAPITest(t *testing.T) (*gin.Engine, *db.DB, string) {
	// Set up test mode for Gin
	gin.SetMode(gin.TestMode)

	// Create a test database
	database := testutils.SetupTestDB(t)

	// Make sure to migrate the StorageProvider model
	err := database.DB.AutoMigrate(&db.StorageProvider{})
	require.NoError(t, err, "Failed to migrate StorageProvider")

	// Create a test user
	user := testutils.CreateTestUser(t, database, "test@example.com", false)

	// Set up the router
	router := gin.New()
	router.Use(gin.Recovery())

	// Initialize routes
	jwtSecret := "test-jwt-secret"
	api.InitializeRoutes(router, database, testutils.SetupTestScheduler(t), jwtSecret)

	// Generate a JWT token for the test user
	token, err := testutils.GenerateTestToken(user.ID, false, jwtSecret)
	require.NoError(t, err, "Failed to generate test token")

	return router, database, token
}

func TestStorageProviderAPI_List(t *testing.T) {
	// Set up test environment
	router, database, token := setupStorageProviderAPITest(t)

	// Create test providers directly in the database
	providers := []db.StorageProvider{
		{
			Name:              "Test SFTP",
			Type:              db.ProviderTypeSFTP,
			Host:              "sftp.example.com",
			Port:              22,
			Username:          "sftpuser",
			EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
			CreatedBy:         1,
		},
		{
			Name:               "Test S3",
			Type:               db.ProviderTypeS3,
			Region:             "us-west-1",
			AccessKey:          "accesskey",
			EncryptedSecretKey: "encrypted_secret_key_placeholder", // This satisfies the validation
			CreatedBy:          1,
		},
	}

	for i := range providers {
		err := database.CreateStorageProvider(&providers[i])
		require.NoError(t, err, "Failed to create test provider")
	}

	// Test listing providers
	req := httptest.NewRequest(http.MethodGet, "/api/storage-providers", nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder := httptest.NewRecorder()
	router.ServeHTTP(recorder, req)

	// Check response
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")

	var respProviders []db.StorageProvider
	err := json.Unmarshal(recorder.Body.Bytes(), &respProviders)
	require.NoError(t, err, "Failed to unmarshal response")

	// Check we got both providers
	assert.Len(t, respProviders, 2, "Expected 2 providers")

	// Check provider names
	providerNames := make([]string, len(respProviders))
	for i, p := range respProviders {
		providerNames[i] = p.Name
	}
	assert.Contains(t, providerNames, "Test SFTP", "Expected 'Test SFTP' provider")
	assert.Contains(t, providerNames, "Test S3", "Expected 'Test S3' provider")
}

func TestStorageProviderAPI_Create(t *testing.T) {
	// Set up test environment
	router, database, token := setupStorageProviderAPITest(t)

	// Test data - ensure all required fields for SFTP validation are present
	newProvider := db.StorageProvider{
		Name:              "New SFTP",
		Type:              db.ProviderTypeSFTP,
		Host:              "new.example.com",
		Port:              2222,
		Username:          "newuser",
		Password:          "newpassword",                    // This will be used by the controller but not stored
		EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
		CreatedBy:         1,
	}

	// Create a direct record in the DB for testing
	// This way we can bypass the encryption logic that would normally happen
	// Just to validate other API endpoints
	err := database.CreateStorageProvider(&newProvider)
	require.NoError(t, err, "Failed to create test provider directly in DB")
	require.NotZero(t, newProvider.ID, "Expected non-zero ID")

	// Now test getting the provider
	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", newProvider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder := httptest.NewRecorder()
	router.ServeHTTP(recorder, req)

	// Check response
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")

	var respProvider db.StorageProvider
	err = json.Unmarshal(recorder.Body.Bytes(), &respProvider)
	require.NoError(t, err, "Failed to unmarshal response")

	// Check the retrieved provider
	assert.Equal(t, newProvider.ID, respProvider.ID, "Expected matching ID")
	assert.Equal(t, "New SFTP", respProvider.Name, "Expected name 'New SFTP'")
	assert.Equal(t, db.ProviderTypeSFTP, respProvider.Type, "Expected type SFTP")
	assert.Equal(t, "new.example.com", respProvider.Host, "Expected host 'new.example.com'")
	assert.Equal(t, 2222, respProvider.Port, "Expected port 2222")
	assert.Equal(t, "newuser", respProvider.Username, "Expected username 'newuser'")
}

func TestStorageProviderAPI_GetById(t *testing.T) {
	// Set up test environment
	router, database, token := setupStorageProviderAPITest(t)

	// Create a test provider
	provider := db.StorageProvider{
		Name:      "Get Test",
		Type:      db.ProviderTypeSFTP,
		Host:      "get.example.com",
		Port:      22,
		Username:  "getuser",
		Password:  "getpassword",
		CreatedBy: 1,
	}

	err := database.CreateStorageProvider(&provider)
	require.NoError(t, err, "Failed to create test provider")
	require.NotZero(t, provider.ID, "Expected non-zero ID")

	// Test getting the provider by ID
	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder := httptest.NewRecorder()
	router.ServeHTTP(recorder, req)

	// Check response
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")

	var respProvider db.StorageProvider
	err = json.Unmarshal(recorder.Body.Bytes(), &respProvider)
	require.NoError(t, err, "Failed to unmarshal response")

	// Check the retrieved provider
	assert.Equal(t, provider.ID, respProvider.ID, "Expected matching ID")
	assert.Equal(t, "Get Test", respProvider.Name, "Expected name 'Get Test'")
	assert.Equal(t, db.ProviderTypeSFTP, respProvider.Type, "Expected type SFTP")
}

func TestStorageProviderAPI_Update(t *testing.T) {
	// Set up test environment
	router, database, token := setupStorageProviderAPITest(t)

	// Create a test provider directly in the database
	provider := db.StorageProvider{
		Name:              "Update Test",
		Type:              db.ProviderTypeSFTP,
		Host:              "update.example.com",
		Port:              22,
		Username:          "updateuser",
		EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
		CreatedBy:         1,
	}

	err := database.CreateStorageProvider(&provider)
	require.NoError(t, err, "Failed to create test provider")
	require.NotZero(t, provider.ID, "Expected non-zero ID")

	// Create a second provider to verify we can update one without affecting others
	otherProvider := db.StorageProvider{
		Name:              "Other Provider",
		Type:              db.ProviderTypeSFTP,
		Host:              "other.example.com",
		Port:              22,
		Username:          "otheruser",
		EncryptedPassword: "other_encrypted_password",
		CreatedBy:         1,
	}
	err = database.CreateStorageProvider(&otherProvider)
	require.NoError(t, err, "Failed to create other test provider")

	// Get the provider via API to check current state
	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder := httptest.NewRecorder()
	router.ServeHTTP(recorder, req)
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status for initial GET")

	// Instead of using map we need to include all required fields to avoid validation errors
	// We don't need to provide sensitive data as our handler should handle that (EncryptedPassword)
	updatedData := db.StorageProvider{
		Name:     "Update Test", // Keep original name
		Type:     db.ProviderTypeSFTP,
		Host:     "update.example.com",
		Port:     2224, // Only change the port
		Username: "updateuser",
	}

	// Prepare request
	body, err := json.Marshal(updatedData)
	require.NoError(t, err, "Failed to marshal provider")

	req = httptest.NewRequest(http.MethodPut, fmt.Sprintf("/api/storage-providers/%d", provider.ID), bytes.NewReader(body))
	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Content-Type", "application/json")

	recorder = httptest.NewRecorder()
	router.ServeHTTP(recorder, req)

	// For debugging
	if recorder.Code != http.StatusOK {
		t.Logf("Response body: %s", recorder.Body.String())
	}

	// Check response
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")

	// Get the updated provider to verify changes
	req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder = httptest.NewRecorder()
	router.ServeHTTP(recorder, req)
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status for final GET")

	var updatedProvider db.StorageProvider
	err = json.Unmarshal(recorder.Body.Bytes(), &updatedProvider)
	require.NoError(t, err, "Failed to unmarshal response")

	// Check the updated provider
	assert.Equal(t, provider.ID, updatedProvider.ID, "Expected matching ID")
	assert.Equal(t, 2224, updatedProvider.Port, "Expected updated port")

	// Verify other provider was not affected
	req = httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", otherProvider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder = httptest.NewRecorder()
	router.ServeHTTP(recorder, req)
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status for other provider")

	var otherProviderUpdated db.StorageProvider
	err = json.Unmarshal(recorder.Body.Bytes(), &otherProviderUpdated)
	require.NoError(t, err, "Failed to unmarshal response")
	assert.Equal(t, 22, otherProviderUpdated.Port, "Expected other provider's port to remain unchanged")
}

func TestStorageProviderAPI_Delete(t *testing.T) {
	// Set up test environment
	router, database, token := setupStorageProviderAPITest(t)

	// Create a test provider directly in the database
	provider := db.StorageProvider{
		Name:              "Delete Test",
		Type:              db.ProviderTypeSFTP,
		Host:              "delete.example.com",
		Port:              22,
		Username:          "deleteuser",
		EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
		CreatedBy:         1,
	}

	err := database.CreateStorageProvider(&provider)
	require.NoError(t, err, "Failed to create test provider")
	require.NotZero(t, provider.ID, "Expected non-zero ID")

	// Test deleting the provider
	req := httptest.NewRequest(http.MethodDelete, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder := httptest.NewRecorder()
	router.ServeHTTP(recorder, req)

	// Check response
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")

	// Verify deletion
	_, err = database.GetStorageProvider(provider.ID)
	assert.Error(t, err, "Expected error when getting deleted provider")
}

func TestStorageProviderAPI_TestConnection(t *testing.T) {
	// Set up test environment
	router, database, token := setupStorageProviderAPITest(t)

	// Create a test provider directly in the database
	provider := db.StorageProvider{
		Name:              "Test Connection",
		Type:              db.ProviderTypeSFTP,
		Host:              "testconn.example.com",
		Port:              22,
		Username:          "testconnuser",
		EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
		CreatedBy:         1,
	}

	err := database.CreateStorageProvider(&provider)
	require.NoError(t, err, "Failed to create test provider")
	require.NotZero(t, provider.ID, "Expected non-zero ID")

	// Test the connection test endpoint
	req := httptest.NewRequest(http.MethodPost, fmt.Sprintf("/api/storage-providers/%d/test", provider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+token)

	recorder := httptest.NewRecorder()
	router.ServeHTTP(recorder, req)

	// Check response
	assert.Equal(t, http.StatusOK, recorder.Code, "Expected 200 OK status")

	var resp map[string]interface{}
	err = json.Unmarshal(recorder.Body.Bytes(), &resp)
	require.NoError(t, err, "Failed to unmarshal response")

	// Check response fields
	assert.Equal(t, "success", resp["status"], "Expected status 'success'")
	assert.NotNil(t, resp["provider"], "Expected provider info")
}

func TestStorageProviderAPI_AccessControl(t *testing.T) {
	// Set up test environment
	router, database, _ := setupStorageProviderAPITest(t)

	// Create a second user
	user2 := testutils.CreateTestUser(t, database, "user2@example.com", false)
	user2Token, err := testutils.GenerateTestToken(user2.ID, false, "test-jwt-secret")
	require.NoError(t, err, "Failed to generate token for user2")

	// Create a provider owned by user 1 directly in the database
	provider := db.StorageProvider{
		Name:              "User1 Provider",
		Type:              db.ProviderTypeSFTP,
		Host:              "user1.example.com",
		Port:              22,
		Username:          "user1",
		EncryptedPassword: "encrypted_password_placeholder", // This satisfies the validation
		CreatedBy:         1,                                // User 1
	}

	err = database.CreateStorageProvider(&provider)
	require.NoError(t, err, "Failed to create test provider")

	// Try to access the provider with user2's token
	req := httptest.NewRequest(http.MethodGet, fmt.Sprintf("/api/storage-providers/%d", provider.ID), nil)
	req.Header.Set("Authorization", "Bearer "+user2Token)

	recorder := httptest.NewRecorder()
	router.ServeHTTP(recorder, req)

	// Check response - should be not found or forbidden
	assert.True(t, recorder.Code == http.StatusNotFound || recorder.Code == http.StatusForbidden,
		"Expected 404 Not Found or 403 Forbidden status")
}