package sqlserverflexalpha

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 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
}

// 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.UpdateInstanceRequestPayloadNetwork{
			Acl: &netAcl,
		},
		Replicas:      &replVal,
		RetentionDays: m.RetentionDays.ValueInt64Pointer(),
		Storage:       &sqlserverflex.StorageUpdate{Size: m.Storage.Size.ValueInt64Pointer()},
		Version:       sqlserverflex.UpdateInstanceRequestPayloadGetVersionAttributeType(m.Version.ValueStringPointer()),
	}, nil
}