package sqlserverflexbeta

import (
	"context"
	"fmt"

	"github.com/hashicorp/terraform-plugin-framework/diag"
	"github.com/hashicorp/terraform-plugin-framework/types"

	sqlserverflexbeta "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
	sqlserverflexbetaResGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance/resources_gen"
)

func mapResponseToModel(
	ctx context.Context,
	resp *sqlserverflexbeta.GetUserResponse,
	m *dataSourceModel,
	tfDiags diag.Diagnostics,
) error {
	if resp == nil {
		return fmt.Errorf("response is nil")
	}

	m.Id = types.Int64Value(resp.GetId())
	m.UserId = types.Int64Value(resp.GetId())
	m.Username = types.StringValue(resp.GetUsername())
	m.Port = types.Int64Value(resp.GetPort())
	m.Host = types.StringValue(resp.GetHost())
	m.DefaultDatabase = types.StringValue(resp.GetDefaultDatabase())
	m.Status = types.StringValue(resp.GetStatus())

	if resp.Roles != nil {
		roles, diags := types.ListValueFrom(ctx, types.StringType, *resp.Roles)
		tfDiags.Append(diags...)
		if tfDiags.HasError() {
			return fmt.Errorf("failed to map roles")
		}
		m.Roles = roles
	} else {
		m.Roles = types.ListNull(types.StringType)
	}

	if resp.Status != nil {
		m.Status = types.StringValue(*resp.Status)
	} else {
		m.Status = types.StringNull()
	}

	// TODO: complete and refactor

	/*
		sampleList, diags := types.ListValueFrom(ctx, types.StringType, resp.GetList())
		tfDiags.Append(diags...)
		if diags.HasError() {
			return fmt.Errorf(
				"error converting list response value",
			)
		}
		sample, diags := sqlserverflexbetaResGen.NewSampleValue(
			sqlserverflexbetaResGen.SampleValue{}.AttributeTypes(ctx),
			map[string]attr.Value{
				"field":     types.StringValue(string(resp.GetField())),
			},
		)
		tfDiags.Append(diags...)
		if diags.HasError() {
			return fmt.Errorf(
				"error converting sample response value",
				"sample",
				types.StringValue(string(resp.GetField())),
			)
		}
		m.Sample = sample
	*/
	return nil
}

// TODO: handle encryption field mapping when API supports it
func handleEncryption(
	m *dataSourceModel,
	resp *sqlserverflexbeta.GetUserResponse,
) sqlserverflexbetaResGen.EncryptionValue {
	/*
		if !resp.HasEncryption() ||

			resp.Encryption == nil ||
			resp.Encryption.KekKeyId == nil ||
			resp.Encryption.KekKeyRingId == nil ||
			resp.Encryption.KekKeyVersion == nil ||
			resp.Encryption.ServiceAccount == nil {

			if m.Encryption.IsNull() || m.Encryption.IsUnknown() {
				return sqlserverflexbetaResGen.NewEncryptionValueNull()
			}
			return m.Encryption
		}

		enc := sqlserverflexbetaResGen.NewEncryptionValueNull()
		if kVal, ok := resp.Encryption.GetKekKeyIdOk(); ok {
			enc.KekKeyId = types.StringValue(kVal)
		}
		if kkVal, ok := resp.Encryption.GetKekKeyRingIdOk(); ok {
			enc.KekKeyRingId = types.StringValue(kkVal)
		}
		if kkvVal, ok := resp.Encryption.GetKekKeyVersionOk(); ok {
			enc.KekKeyVersion = types.StringValue(kkvVal)
		}
		if sa, ok := resp.Encryption.GetServiceAccountOk(); ok {
			enc.ServiceAccount = types.StringValue(sa)
		}
		return enc
	*/
	return sqlserverflexbetaResGen.NewEncryptionValueNull()
}

func toCreatePayload(
	ctx context.Context,
	model *dataSourceModel,
) (*sqlserverflexbeta.CreateUserRequestPayload, error) {
	if model == nil {
		return nil, fmt.Errorf("nil model")
	}

	var roles []sqlserverflexbeta.UserRole
	if !model.Roles.IsNull() && !model.Roles.IsUnknown() {
		diags := model.Roles.ElementsAs(ctx, &roles, false)
		if diags.HasError() {
			return nil, fmt.Errorf("failed to convert roles: %v", diags)
		}
	}

	return &sqlserverflexbeta.CreateUserRequestPayload{
		DefaultDatabase: model.DefaultDatabase.ValueStringPointer(),
		Username:        model.Username.ValueStringPointer(),
		Roles:           &roles,
	}, nil
}