package postgresflexalpha

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/postgresflexalpha"
	datasource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/database/datasources_gen"
	resource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/database/resources_gen"
)

func TestMapFields(t *testing.T) {
	type given struct {
		source *postgresflexalpha.ListDatabase
		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: &postgresflexalpha.ListDatabase{
					Id:    utils.Ptr(int64(1)),
					Name:  utils.Ptr("my-db"),
					Owner: utils.Ptr("\"my-owner\""),
				},
				model:  &DataSourceModel{},
				region: "eu01",
			},
			expected: expected{
				model: &DataSourceModel{
					DatabaseModel: datasource.DatabaseModel{
						Id:    types.Int64Value(1),
						Name:  types.StringValue("my-db"),
						Owner: types.StringValue("my-owner"),
					},
					Region: types.StringValue("eu01"),
				},
			},
		},
		{
			name: "should preserve existing model ID",
			given: given{
				source: &postgresflexalpha.ListDatabase{
					Id:   utils.Ptr(int64(1)),
					Name: utils.Ptr("my-db"),
				},
				model: &DataSourceModel{
					DatabaseModel: datasource.DatabaseModel{
						Id: types.Int64Value(1),
					},
				},
				region: "eu01",
			},
			expected: expected{
				model: &DataSourceModel{
					DatabaseModel: datasource.DatabaseModel{
						Id:    types.Int64Value(1),
						Name:  types.StringValue("my-db"),
						Owner: types.StringNull(),
					},
					Region: types.StringValue("eu01"),
				},
			},
		},
		{
			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: &postgresflexalpha.ListDatabase{Id: nil},
				model:  &DataSourceModel{},
			},
			expected: expected{err: true},
		},
		{
			name: "should fail on nil model",
			given: given{
				source: &postgresflexalpha.ListDatabase{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 *postgresflexalpha.ListDatabase
		model  *ResourceModel
	}
	type expected struct {
		model *ResourceModel
		err   bool
	}

	testcases := []struct {
		name     string
		given    given
		expected expected
	}{
		{
			name: "should map fields correctly",
			given: given{
				source: &postgresflexalpha.ListDatabase{
					Id:    utils.Ptr(int64(1)),
					Name:  utils.Ptr("my-db"),
					Owner: utils.Ptr("\"my-owner\""),
				},
				model: &ResourceModel{},
			},
			expected: expected{
				model: &ResourceModel{
					DatabaseModel: resource.DatabaseModel{
						Id:    types.Int64Value(1),
						Name:  types.StringValue("my-db"),
						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)
				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 *postgresflexalpha.CreateDatabaseRequestPayload
		err     bool
	}

	testcases := []struct {
		name     string
		given    given
		expected expected
	}{
		{
			name: "should convert model to payload",
			given: given{
				model: &ResourceModel{
					DatabaseModel: resource.DatabaseModel{
						Name:  types.StringValue("my-db"),
						Owner: types.StringValue("my-owner"),
					},
				},
			},
			expected: expected{
				payload: &postgresflexalpha.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)
					}
				}
			},
		)
	}
}

func TestCleanString(t *testing.T) {
	testcases := []struct {
		name     string
		given    *string
		expected *string
	}{
		{
			name:     "should remove quotes",
			given:    utils.Ptr("\"quoted\""),
			expected: utils.Ptr("quoted"),
		},
		{
			name:     "should handle nil",
			given:    nil,
			expected: nil,
		},
		{
			name:     "should not change unquoted string",
			given:    utils.Ptr("unquoted"),
			expected: utils.Ptr("unquoted"),
		},
	}

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