package sqlserverflexbeta

import (
	"testing"

	"github.com/google/go-cmp/cmp"
	"github.com/hashicorp/terraform-plugin-framework/types"
	"github.com/stackitcloud/stackit-sdk-go/core/utils"
	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
	datasource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/database/datasources_gen"
)

func TestMapFields(t *testing.T) {
	type given struct {
		source *sqlserverflexbeta.GetDatabaseResponse
		model  *dataSourceModel
		region string
	}
	type expected struct {
		model *dataSourceModel
		err   bool
	}

	testcases := []struct {
		name     string
		given    given
		expected expected
	}{
		{
			name: "should map fields correctly",
			given: given{
				source: &sqlserverflexbeta.GetDatabaseResponse{
					Id:                 utils.Ptr(int64(1)),
					Name:               utils.Ptr("my-db"),
					CollationName:      utils.Ptr("collation"),
					CompatibilityLevel: utils.Ptr(int64(150)),
					Owner:              utils.Ptr("\"my-owner\""),
				},
				model: &dataSourceModel{
					DatabaseModel: datasource.DatabaseModel{
						ProjectId:  types.StringValue("my-project"),
						InstanceId: types.StringValue("my-instance"),
					},
				},
				region: "eu01",
			},
			expected: expected{
				model: &dataSourceModel{
					DatabaseModel: datasource.DatabaseModel{
						Id:                 types.Int64Value(1),
						Name:               types.StringValue("my-db"),
						DatabaseName:       types.StringValue("my-db"),
						Owner:              types.StringValue("my-owner"),
						Region:             types.StringValue("eu01"),
						InstanceId:         types.StringValue("my-instance"),
						ProjectId:          types.StringValue("my-project"),
						CompatibilityLevel: types.Int64Value(150),
						CollationName:      types.StringValue("collation"),
					},
					TerraformId: types.StringValue("my-project,eu01,my-instance,my-db"),
				},
			},
		},
		{
			name: "should fail on nil source",
			given: given{
				source: nil,
				model:  &dataSourceModel{},
			},
			expected: expected{err: true},
		},
		{
			name: "should fail on nil source ID",
			given: given{
				source: &sqlserverflexbeta.GetDatabaseResponse{Id: nil},
				model:  &dataSourceModel{},
			},
			expected: expected{err: true},
		},
		{
			name: "should fail on nil model",
			given: given{
				source: &sqlserverflexbeta.GetDatabaseResponse{Id: utils.Ptr(int64(1))},
				model:  nil,
			},
			expected: expected{err: true},
		},
	}

	for _, tc := range testcases {
		t.Run(
			tc.name, func(t *testing.T) {
				err := mapFields(tc.given.source, tc.given.model, tc.given.region)
				if (err != nil) != tc.expected.err {
					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
				}
				if err == nil {
					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
						t.Errorf("model mismatch (-want +got):\n%s", diff)
					}
				}
			},
		)
	}
}

func TestMapResourceFields(t *testing.T) {
	type given struct {
		source *sqlserverflexbeta.GetDatabaseResponse
		model  *resourceModel
		region string
	}
	type expected struct {
		model *resourceModel
		err   bool
	}

	testcases := []struct {
		name     string
		given    given
		expected expected
	}{
		{
			name: "should map fields correctly",
			given: given{
				source: &sqlserverflexbeta.GetDatabaseResponse{
					Id:    utils.Ptr(int64(1)),
					Name:  utils.Ptr("my-db"),
					Owner: utils.Ptr("\"my-owner\""),
				},
				model: &resourceModel{
					ProjectId:  types.StringValue("my-project"),
					InstanceId: types.StringValue("my-instance"),
				},
				region: "eu01",
			},
			expected: expected{
				model: &resourceModel{
					Id:           types.Int64Value(1),
					Name:         types.StringValue("my-db"),
					DatabaseName: types.StringValue("my-db"),
					InstanceId:   types.StringValue("my-instance"),
					ProjectId:    types.StringValue("my-project"),
					Region:       types.StringValue("eu01"),
					Owner:        types.StringValue("my-owner"),
				},
			},
		},
		{
			name: "should fail on nil source",
			given: given{
				source: nil,
				model:  &resourceModel{},
			},
			expected: expected{err: true},
		},
	}

	for _, tc := range testcases {
		t.Run(
			tc.name, func(t *testing.T) {
				err := mapResourceFields(tc.given.source, tc.given.model, tc.given.region)
				if (err != nil) != tc.expected.err {
					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
				}
				if err == nil {
					if diff := cmp.Diff(tc.expected.model, tc.given.model); diff != "" {
						t.Errorf("model mismatch (-want +got):\n%s", diff)
					}
				}
			},
		)
	}
}

func TestToCreatePayload(t *testing.T) {
	type given struct {
		model *resourceModel
	}
	type expected struct {
		payload *sqlserverflexbeta.CreateDatabaseRequestPayload
		err     bool
	}

	testcases := []struct {
		name     string
		given    given
		expected expected
	}{
		{
			name: "should convert model to payload",
			given: given{
				model: &resourceModel{
					Name:  types.StringValue("my-db"),
					Owner: types.StringValue("my-owner"),
				},
			},
			expected: expected{
				payload: &sqlserverflexbeta.CreateDatabaseRequestPayload{
					Name:  utils.Ptr("my-db"),
					Owner: utils.Ptr("my-owner"),
				},
			},
		},
		{
			name:     "should fail on nil model",
			given:    given{model: nil},
			expected: expected{err: true},
		},
	}

	for _, tc := range testcases {
		t.Run(
			tc.name, func(t *testing.T) {
				actual, err := toCreatePayload(tc.given.model)
				if (err != nil) != tc.expected.err {
					t.Fatalf("expected error: %v, got: %v", tc.expected.err, err)
				}
				if err == nil {
					if diff := cmp.Diff(tc.expected.payload, actual); diff != "" {
						t.Errorf("payload mismatch (-want +got):\n%s", diff)
					}
				}
			},
		)
	}
}