package sqlserverflexbeta

import (
	"context"
	"errors"
	"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"

	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/sqlserverflexbeta"
	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/conversion"
	sqlserverflexbetaDataGen "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/sqlserverflexbeta/instance/datasources_gen"
	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.GetInstanceResponse,
	m *sqlserverflexbetaResGen.InstanceModel,
	tfDiags diag.Diagnostics,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	m.Edition = types.StringValue(string(resp.GetEdition()))
	m.Encryption = handleEncryption(ctx, 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 := sqlserverflexbetaResGen.NewNetworkValue(
		sqlserverflexbetaResGen.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 errors.New("error converting network response value")
	}
	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 := sqlserverflexbetaResGen.NewStorageValue(
		sqlserverflexbetaResGen.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 mapDataResponseToModel(
	ctx context.Context,
	resp *sqlserverflexbeta.GetInstanceResponse,
	m *dataSourceModel,
	tfDiags diag.Diagnostics,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	m.Edition = types.StringValue(string(resp.GetEdition()))
	m.Encryption = handleDSEncryption(ctx, 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 := sqlserverflexbetaDataGen.NewNetworkValue(
		sqlserverflexbetaDataGen.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 errors.New("error converting network response value")
	}
	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 := sqlserverflexbetaDataGen.NewStorageValue(
		sqlserverflexbetaDataGen.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(
	ctx context.Context,
	m *sqlserverflexbetaResGen.InstanceModel,
	resp *sqlserverflexbeta.GetInstanceResponse,
) 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.NewEncryptionValueMust(
		sqlserverflexbetaResGen.EncryptionValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"kek_key_id":      types.StringValue(resp.Encryption.GetKekKeyId()),
			"kek_key_ring_id": types.StringValue(resp.Encryption.GetKekKeyRingId()),
			"kek_key_version": types.StringValue(resp.Encryption.GetKekKeyVersion()),
			"service_account": types.StringValue(resp.Encryption.GetServiceAccount()),
		},
	)
	return enc
}

func handleDSEncryption(
	ctx context.Context,
	m *dataSourceModel,
	resp *sqlserverflexbeta.GetInstanceResponse,
) sqlserverflexbetaDataGen.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 sqlserverflexbetaDataGen.NewEncryptionValueNull()
		}
		return m.Encryption
	}

	enc := sqlserverflexbetaDataGen.NewEncryptionValueMust(
		sqlserverflexbetaDataGen.EncryptionValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"kek_key_id":      types.StringValue(resp.Encryption.GetKekKeyId()),
			"kek_key_ring_id": types.StringValue(resp.Encryption.GetKekKeyRingId()),
			"kek_key_version": types.StringValue(resp.Encryption.GetKekKeyVersion()),
			"service_account": types.StringValue(resp.Encryption.GetServiceAccount()),
		},
	)
	return enc
}

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

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

	var encryptionPayload *sqlserverflexbeta.CreateInstanceRequestPayloadGetEncryptionArgType = nil
	if !model.Encryption.IsNull() && !model.Encryption.IsUnknown() {
		encryptionPayload = &sqlserverflexbeta.CreateInstanceRequestPayloadGetEncryptionArgType{}
		encryptionPayload.KekKeyId = model.Encryption.KekKeyId.ValueStringPointer()
		encryptionPayload.KekKeyRingId = model.Encryption.KekKeyRingId.ValueStringPointer()
		encryptionPayload.KekKeyVersion = model.Encryption.KekKeyVersion.ValueStringPointer()
		encryptionPayload.ServiceAccount = model.Encryption.ServiceAccount.ValueStringPointer()
	}

	networkPayload := &sqlserverflexbeta.CreateInstanceRequestPayloadGetNetworkArgType{}
	if !model.Network.IsNull() && !model.Network.IsUnknown() {
		networkPayload.AccessScope = sqlserverflexbeta.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 &sqlserverflexbeta.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: sqlserverflexbeta.CreateInstanceRequestPayloadGetVersionAttributeType(
			conversion.StringValueToPointer(model.Version),
		),
	}, nil
}

func toUpdatePayload(
	ctx context.Context,
	m *sqlserverflexbetaResGen.InstanceModel,
	resp *resource.UpdateResponse,
) (*sqlserverflexbeta.UpdateInstanceRequestPayload, error) {
	if m == nil {
		return nil, fmt.Errorf("nil model")
	}
	if m.Replicas.ValueInt64() > math.MaxUint32 {
		return nil, fmt.Errorf("replicas value is too big for uint32")
	}
	replVal := sqlserverflexbeta.Replicas(uint32(m.Replicas.ValueInt64())) // nolint:gosec // check is performed above

	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 &sqlserverflexbeta.UpdateInstanceRequestPayload{
		BackupSchedule: m.BackupSchedule.ValueStringPointer(),
		FlavorId:       m.FlavorId.ValueStringPointer(),
		Name:           m.Name.ValueStringPointer(),
		Network:        sqlserverflexbeta.NewUpdateInstanceRequestPayloadNetwork(netAcl),
		Replicas:       &replVal,
		RetentionDays:  m.RetentionDays.ValueInt64Pointer(),
		Storage:        &sqlserverflexbeta.StorageUpdate{Size: m.Storage.Size.ValueInt64Pointer()},
		Version: sqlserverflexbeta.UpdateInstanceRequestPayloadGetVersionAttributeType(
			m.Version.ValueStringPointer(),
		),
	}, nil
}