package sqlserverflex

import (
	"context"
	"fmt"
	"math"

	"github.com/hashicorp/terraform-plugin-framework/attr"
	"github.com/hashicorp/terraform-plugin-framework/diag"
	"github.com/hashicorp/terraform-plugin-framework/resource"
	"github.com/hashicorp/terraform-plugin-framework/types"
	sqlserverflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexalpha"
	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
	sqlserverflexResGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexalpha/instance/resources_gen"
)

func mapResponseToModel(
	ctx context.Context,
	resp *sqlserverflex.GetInstanceResponse,
	m *sqlserverflexResGen.InstanceModel,
	tfDiags diag.Diagnostics,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	m.Edition = types.StringValue(string(resp.GetEdition()))
	m.Encryption = handleEncryption(m, resp)
	m.FlavorId = types.StringValue(resp.GetFlavorId())
	m.Id = types.StringValue(resp.GetId())
	m.InstanceId = types.StringValue(resp.GetId())
	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())
	m.Name = types.StringValue(resp.GetName())
	netAcl, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
	tfDiags.Append(diags...)
	if diags.HasError() {
		return fmt.Errorf(
			"error converting network acl response value",
		)
	}
	net, diags := sqlserverflexResGen.NewNetworkValue(
		sqlserverflexResGen.NetworkValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"access_scope":     types.StringValue(string(resp.Network.GetAccessScope())),
			"acl":              netAcl,
			"instance_address": types.StringValue(resp.Network.GetInstanceAddress()),
			"router_address":   types.StringValue(resp.Network.GetRouterAddress()),
		},
	)
	tfDiags.Append(diags...)
	if diags.HasError() {
		return fmt.Errorf(
			"error converting network response value",
			"access_scope",
			types.StringValue(string(resp.Network.GetAccessScope())),
			"acl",
			netAcl,
			"instance_address",
			types.StringValue(resp.Network.GetInstanceAddress()),
			"router_address",
			types.StringValue(resp.Network.GetRouterAddress()),
		)
	}
	m.Network = net
	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
	m.RetentionDays = types.Int64Value(resp.GetRetentionDays())
	m.Status = types.StringValue(string(resp.GetStatus()))

	stor, diags := sqlserverflexResGen.NewStorageValue(
		sqlserverflexResGen.StorageValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"class": types.StringValue(resp.Storage.GetClass()),
			"size":  types.Int64Value(resp.Storage.GetSize()),
		},
	)
	tfDiags.Append(diags...)
	if diags.HasError() {
		return fmt.Errorf("error converting storage response value")
	}
	m.Storage = stor

	m.Version = types.StringValue(string(resp.GetVersion()))
	return nil
}

func handleEncryption(
	m *sqlserverflexResGen.InstanceModel,
	resp *sqlserverflex.GetInstanceResponse,
) sqlserverflexResGen.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 sqlserverflexResGen.NewEncryptionValueNull()
		}
		return m.Encryption
	}

	enc := sqlserverflexResGen.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
}

//func mapFields(
//	ctx context.Context,
//	resp *sqlserverflex.GetInstanceResponse,
//	model *Model,
//	storage *storageModel,
//	encryption *encryptionModel,
//	network *networkModel,
//	region string,
//) error {
//	if resp == nil {
//		return fmt.Errorf("response input is nil")
//	}
//	if model == nil {
//		return fmt.Errorf("model input is nil")
//	}
//	instance := resp
//
//	var instanceId string
//	if model.InstanceId.ValueString() != "" {
//		instanceId = model.InstanceId.ValueString()
//	} else if instance.Id != nil {
//		instanceId = *instance.Id
//	} else {
//		return fmt.Errorf("instance id not present")
//	}
//
//	var storageValues map[string]attr.Value
//	if instance.Storage == nil {
//		storageValues = map[string]attr.Value{
//			"class": storage.Class,
//			"size":  storage.Size,
//		}
//	} else {
//		storageValues = map[string]attr.Value{
//			"class": types.StringValue(*instance.Storage.Class),
//			"size":  types.Int64PointerValue(instance.Storage.Size),
//		}
//	}
//	storageObject, diags := types.ObjectValue(storageTypes, storageValues)
//	if diags.HasError() {
//		return fmt.Errorf("creating storage: %w", core.DiagsToError(diags))
//	}
//
//	var encryptionValues map[string]attr.Value
//	if instance.Encryption == nil {
//		encryptionValues = map[string]attr.Value{
//			"keyring_id":      encryption.KeyRingId,
//			"key_id":          encryption.KeyId,
//			"key_version":     encryption.KeyVersion,
//			"service_account": encryption.ServiceAccount,
//		}
//	} else {
//		encryptionValues = map[string]attr.Value{
//			"keyring_id":      types.StringValue(*instance.Encryption.KekKeyRingId),
//			"key_id":          types.StringValue(*instance.Encryption.KekKeyId),
//			"key_version":     types.StringValue(*instance.Encryption.KekKeyVersion),
//			"service_account": types.StringValue(*instance.Encryption.ServiceAccount),
//		}
//	}
//	encryptionObject, diags := types.ObjectValue(encryptionTypes, encryptionValues)
//	if diags.HasError() {
//		return fmt.Errorf("creating encryption: %w", core.DiagsToError(diags))
//	}
//
//	var networkValues map[string]attr.Value
//	if instance.Network == nil {
//		networkValues = map[string]attr.Value{
//			"acl":              network.ACL,
//			"access_scope":     network.AccessScope,
//			"instance_address": network.InstanceAddress,
//			"router_address":   network.RouterAddress,
//		}
//	} else {
//		aclList, diags := types.ListValueFrom(ctx, types.StringType, *instance.Network.Acl)
//		if diags.HasError() {
//			return fmt.Errorf("creating network (acl list): %w", core.DiagsToError(diags))
//		}
//
//		var routerAddress string
//		if instance.Network.RouterAddress != nil {
//			routerAddress = *instance.Network.RouterAddress
//			diags.AddWarning("field missing while mapping fields", "router_address was empty in API response")
//		}
//		if instance.Network.InstanceAddress == nil {
//			return fmt.Errorf("creating network: no instance address returned")
//		}
//		networkValues = map[string]attr.Value{
//			"acl":              aclList,
//			"access_scope":     types.StringValue(string(*instance.Network.AccessScope)),
//			"instance_address": types.StringValue(*instance.Network.InstanceAddress),
//			"router_address":   types.StringValue(routerAddress),
//		}
//	}
//	networkObject, diags := types.ObjectValue(networkTypes, networkValues)
//	if diags.HasError() {
//		return fmt.Errorf("creating network: %w", core.DiagsToError(diags))
//	}
//
//	simplifiedModelBackupSchedule := utils.SimplifyBackupSchedule(model.BackupSchedule.ValueString())
//	// If the value returned by the API is different from the one in the model after simplification,
//	// we update the model so that it causes an error in Terraform
//	if simplifiedModelBackupSchedule != types.StringPointerValue(instance.BackupSchedule).ValueString() {
//		model.BackupSchedule = types.StringPointerValue(instance.BackupSchedule)
//	}
//
//	if instance.Replicas == nil {
//		return fmt.Errorf("instance has no replicas set")
//	}
//
//	if instance.RetentionDays == nil {
//		return fmt.Errorf("instance has no retention days set")
//	}
//
//	if instance.Version == nil {
//		return fmt.Errorf("instance has no version set")
//	}
//
//	if instance.Edition == nil {
//		return fmt.Errorf("instance has no edition set")
//	}
//
//	if instance.Status == nil {
//		return fmt.Errorf("instance has no status set")
//	}
//
//	if instance.IsDeletable == nil {
//		return fmt.Errorf("instance has no IsDeletable set")
//	}
//
//	model.Id = utils.BuildInternalTerraformId(model.ProjectId.ValueString(), region, instanceId)
//	model.InstanceId = types.StringValue(instanceId)
//	model.Name = types.StringPointerValue(instance.Name)
//	model.FlavorId = types.StringPointerValue(instance.FlavorId)
//	model.Replicas = types.Int64Value(int64(*instance.Replicas))
//	model.Storage = storageObject
//	model.Version = types.StringValue(string(*instance.Version))
//	model.Edition = types.StringValue(string(*instance.Edition))
//	model.Region = types.StringValue(region)
//	model.Encryption = encryptionObject
//	model.Network = networkObject
//	model.RetentionDays = types.Int64Value(*instance.RetentionDays)
//	model.Status = types.StringValue(string(*instance.Status))
//	model.IsDeletable = types.BoolValue(*instance.IsDeletable)
//	return nil
//}

func toCreatePayload(
	ctx context.Context,
	model *sqlserverflexResGen.InstanceModel,
) (*sqlserverflex.CreateInstanceRequestPayload, error) {
	if model == nil {
		return nil, fmt.Errorf("nil model")
	}

	storagePayload := &sqlserverflex.CreateInstanceRequestPayloadGetStorageArgType{}
	if !model.Storage.IsNull() && !model.Storage.IsUnknown() {
		storagePayload.Class = model.Storage.Class.ValueStringPointer()
		storagePayload.Size = model.Storage.Size.ValueInt64Pointer()
	}

	var encryptionPayload *sqlserverflex.CreateInstanceRequestPayloadGetEncryptionArgType = nil
	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() &&
		!model.Encryption.KekKeyId.IsNull() && model.Encryption.KekKeyId.IsUnknown() && model.Encryption.KekKeyId.ValueString() != "" &&
		!model.Encryption.KekKeyRingId.IsNull() && !model.Encryption.KekKeyRingId.IsUnknown() && model.Encryption.KekKeyRingId.ValueString() != "" &&
		!model.Encryption.KekKeyVersion.IsNull() && !model.Encryption.KekKeyVersion.IsUnknown() && model.Encryption.KekKeyVersion.ValueString() != "" &&
		!model.Encryption.ServiceAccount.IsNull() && !model.Encryption.ServiceAccount.IsUnknown() && model.Encryption.ServiceAccount.ValueString() != "" {
		encryptionPayload = &sqlserverflex.CreateInstanceRequestPayloadGetEncryptionArgType{
			KekKeyId:       model.Encryption.KekKeyId.ValueStringPointer(),
			KekKeyRingId:   model.Encryption.KekKeyVersion.ValueStringPointer(),
			KekKeyVersion:  model.Encryption.KekKeyRingId.ValueStringPointer(),
			ServiceAccount: model.Encryption.ServiceAccount.ValueStringPointer(),
		}
	}

	networkPayload := &sqlserverflex.CreateInstanceRequestPayloadGetNetworkArgType{}
	if !model.Network.IsNull() && !model.Network.IsUnknown() {
		networkPayload.AccessScope = sqlserverflex.CreateInstanceRequestPayloadNetworkGetAccessScopeAttributeType(
			model.Network.AccessScope.ValueStringPointer(),
		)

		var resList []string
		diags := model.Network.Acl.ElementsAs(ctx, &resList, false)
		if diags.HasError() {
			return nil, fmt.Errorf("error converting network acl list")
		}
		networkPayload.Acl = &resList
	}

	return &sqlserverflex.CreateInstanceRequestPayload{
		BackupSchedule: conversion.StringValueToPointer(model.BackupSchedule),
		Encryption:     encryptionPayload,
		FlavorId:       conversion.StringValueToPointer(model.FlavorId),
		Name:           conversion.StringValueToPointer(model.Name),
		Network:        networkPayload,
		RetentionDays:  conversion.Int64ValueToPointer(model.RetentionDays),
		Storage:        storagePayload,
		Version:        sqlserverflex.CreateInstanceRequestPayloadGetVersionAttributeType(conversion.StringValueToPointer(model.Version)),
	}, nil
}

////nolint:unused // TODO: remove if not needed later
//func toUpdatePartiallyPayload(
//	model *Model,
//	storage *storageModel,
//	network *networkModel,
//) (*sqlserverflex.UpdateInstancePartiallyRequestPayload, error) {
//	if model == nil {
//		return nil, fmt.Errorf("nil model")
//	}
//
//	storagePayload := &sqlserverflex.UpdateInstanceRequestPayloadGetStorageArgType{}
//	if storage != nil {
//		storagePayload.Size = conversion.Int64ValueToPointer(storage.Size)
//	}
//
//	var aclElements []string
//	if network != nil && !network.ACL.IsNull() && !network.ACL.IsUnknown() {
//		aclElements = make([]string, 0, len(network.ACL.Elements()))
//		diags := network.ACL.ElementsAs(context.TODO(), &aclElements, false)
//		if diags.HasError() {
//			return nil, fmt.Errorf("creating network: %w", core.DiagsToError(diags))
//		}
//	}
//
//	networkPayload := &sqlserverflex.UpdateInstancePartiallyRequestPayloadGetNetworkArgType{}
//	if network != nil {
//		networkPayload.AccessScope = sqlserverflex.UpdateInstancePartiallyRequestPayloadNetworkGetAccessScopeAttributeType(conversion.StringValueToPointer(network.AccessScope))
//		networkPayload.Acl = &aclElements
//	}
//
//	if model.Replicas.ValueInt64() > math.MaxInt32 {
//		return nil, fmt.Errorf("replica count too big: %d", model.Replicas.ValueInt64())
//	}
//	replCount := int32(model.Replicas.ValueInt64()) // nolint:gosec // check is performed above
//	return &sqlserverflex.UpdateInstancePartiallyRequestPayload{
//		BackupSchedule: conversion.StringValueToPointer(model.BackupSchedule),
//		FlavorId:       conversion.StringValueToPointer(model.FlavorId),
//		Name:           conversion.StringValueToPointer(model.Name),
//		Network:        networkPayload,
//		Replicas:       sqlserverflex.UpdateInstancePartiallyRequestPayloadGetReplicasAttributeType(&replCount),
//		RetentionDays:  conversion.Int64ValueToPointer(model.RetentionDays),
//		Storage:        storagePayload,
//		Version:        sqlserverflex.UpdateInstancePartiallyRequestPayloadGetVersionAttributeType(conversion.StringValueToPointer(model.Version)),
//	}, nil
//}

// TODO: check func with his args
func toUpdatePayload(
	ctx context.Context,
	m *sqlserverflexResGen.InstanceModel,
	resp *resource.UpdateResponse,
) (*sqlserverflex.UpdateInstanceRequestPayload, error) {
	if m.Replicas.ValueInt64() > math.MaxUint32 {
		return nil, fmt.Errorf("replicas value is too big for uint32")
	}
	replVal := sqlserverflex.Replicas(uint32(m.Replicas.ValueInt64()))

	var netAcl []string
	diags := m.Network.Acl.ElementsAs(ctx, &netAcl, false)
	resp.Diagnostics.Append(diags...)
	if diags.HasError() {
		return nil, fmt.Errorf("error converting model network acl value")
	}
	return &sqlserverflex.UpdateInstanceRequestPayload{
		BackupSchedule: m.BackupSchedule.ValueStringPointer(),
		FlavorId:       m.FlavorId.ValueStringPointer(),
		Name:           m.Name.ValueStringPointer(),
		Network: &sqlserverflex.CreateInstanceRequestPayloadNetwork{
			AccessScope: sqlserverflex.CreateInstanceRequestPayloadNetworkGetAccessScopeAttributeType(m.Network.AccessScope.ValueStringPointer()),
			Acl:         &netAcl,
		},
		Replicas:      &replVal,
		RetentionDays: m.RetentionDays.ValueInt64Pointer(),
		Storage:       &sqlserverflex.StorageUpdate{Size: m.Storage.Size.ValueInt64Pointer()},
		Version:       sqlserverflex.UpdateInstanceRequestPayloadGetVersionAttributeType(m.Version.ValueStringPointer()),
	}, nil
}