resource.go

package instance

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"strings"

	"github.com/hashicorp/terraform-plugin-framework/diag"
	"github.com/hashicorp/terraform-plugin-framework/resource"
	"github.com/hashicorp/terraform-plugin-framework/resource/schema"
	"github.com/hashicorp/terraform-plugin-framework/resource/schema/planmodifier"
	"github.com/hashicorp/terraform-plugin-framework/resource/schema/stringplanmodifier"
	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
	"github.com/hashicorp/terraform-plugin-framework/types"
	"github.com/hashicorp/terraform-plugin-log/tflog"
	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
	logs "github.com/stackitcloud/stackit-sdk-go/services/logs/v1api"
	"github.com/stackitcloud/stackit-sdk-go/services/logs/v1api/wait"
	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/conversion"
	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/services/logs/utils"
	tfutils "github.com/stackitcloud/terraform-provider-stackit/stackit/internal/utils"
	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/validate"
)

var (
	_ resource.Resource                = &logsInstanceResource{}
	_ resource.ResourceWithConfigure   = &logsInstanceResource{}
	_ resource.ResourceWithImportState = &logsInstanceResource{}
	_ resource.ResourceWithModifyPlan  = &logsInstanceResource{}
)

var schemaDescriptions = map[string]string{
	"id":              "Terraform's internal resource identifier. It is structured as \"`project_id`,`region`,`instance_id`\".",
	"instance_id":     "The Logs instance ID",
	"region":          "STACKIT region name the resource is located in. If not defined, the provider region is used.",
	"project_id":      "STACKIT project ID associated with the Logs instance",
	"acl":             "The access control list entries for the Logs instance",
	"created":         "The date and time the creation of the Logs instance was initiated",
	"datasource_url":  "Logs instance datasource URL, can be used in Grafana as datasource URL",
	"description":     "The description of the Logs instance",
	"display_name":    "The displayed name of the Logs instance",
	"ingest_otlp_url": "The Logs instance's ingest logs via OTLP URL",
	"ingest_url":      "The logs instance's ingest logs URL",
	"query_range_url": "The Logs instance's query range URL",
	"query_url":       "The Logs instance's query URL",
	"retention_days":  "The log retention time in days",
	"status": fmt.Sprintf(
		"The status of the Logs instance, possible values: %s",
		tfutils.FormatPossibleValues("active", "deleting", "reconciling"),
	),
}

type Model struct {
	ID            types.String `tfsdk:"id"` // Required by Terraform
	InstanceID    types.String `tfsdk:"instance_id"`
	Region        types.String `tfsdk:"region"`
	ProjectID     types.String `tfsdk:"project_id"`
	ACL           types.List   `tfsdk:"acl"`
	Created       types.String `tfsdk:"created"`
	DatasourceURL types.String `tfsdk:"datasource_url"`
	Description   types.String `tfsdk:"description"`
	DisplayName   types.String `tfsdk:"display_name"`
	IngestOTLPURL types.String `tfsdk:"ingest_otlp_url"`
	IngestURL     types.String `tfsdk:"ingest_url"`
	QueryRangeURL types.String `tfsdk:"query_range_url"`
	QueryURL      types.String `tfsdk:"query_url"`
	RetentionDays types.Int32  `tfsdk:"retention_days"`
	Status        types.String `tfsdk:"status"`
}

type logsInstanceResource struct {
	client       *logs.APIClient
	providerData core.ProviderData
}

func NewLogsInstanceResource() resource.Resource {
	return &logsInstanceResource{}
}

func (r *logsInstanceResource) Configure(ctx context.Context, req resource.ConfigureRequest, resp *resource.ConfigureResponse) {
	providerData, ok := conversion.ParseProviderData(ctx, req.ProviderData, &resp.Diagnostics)
	if !ok {
		return
	}

	apiClient := utils.ConfigureClient(ctx, &providerData, &resp.Diagnostics)
	if resp.Diagnostics.HasError() {
		return
	}
	r.client = apiClient
	r.providerData = providerData
	tflog.Info(ctx, "Logs client configured")
}

func (r *logsInstanceResource) ModifyPlan(ctx context.Context, req resource.ModifyPlanRequest, resp *resource.ModifyPlanResponse) { // nolint:gocritic // function signature required by Terraform
	var configModel Model
	if req.Config.Raw.IsNull() {
		return
	}
	resp.Diagnostics.Append(req.Config.Get(ctx, &configModel)...)
	if resp.Diagnostics.HasError() {
		return
	}

	var planModel Model
	resp.Diagnostics.Append(req.Plan.Get(ctx, &planModel)...)
	if resp.Diagnostics.HasError() {
		return
	}

	tfutils.AdaptRegion(ctx, configModel.Region, &planModel.Region, r.providerData.GetRegion(), resp)
	if resp.Diagnostics.HasError() {
		return
	}

	resp.Diagnostics.Append(resp.Plan.Set(ctx, planModel)...)
	if resp.Diagnostics.HasError() {
		return
	}
}

func (r *logsInstanceResource) Metadata(_ context.Context, req resource.MetadataRequest, resp *resource.MetadataResponse) {
	resp.TypeName = req.ProviderTypeName + "_logs_instance"
}

func (r *logsInstanceResource) Schema(_ context.Context, _ resource.SchemaRequest, resp *resource.SchemaResponse) {
	resp.Schema = schema.Schema{
		Description: fmt.Sprintf("Logs instance resource schema. %s", core.ResourceRegionFallbackDocstring),
		Attributes: map[string]schema.Attribute{
			"id": schema.StringAttribute{
				Description: schemaDescriptions["id"],
				Computed:    true,
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.UseStateForUnknown(),
				},
			},
			"instance_id": schema.StringAttribute{
				Description: schemaDescriptions["instance_id"],
				Computed:    true,
				Validators: []validator.String{
					validate.UUID(),
					validate.NoSeparator(),
				},
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.UseStateForUnknown(),
				},
			},
			"region": schema.StringAttribute{
				Description: schemaDescriptions["region"],
				Optional:    true,
				// must be computed to allow for storing the override value from the provider
				Computed: true,
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.RequiresReplace(),
				},
			},
			"project_id": schema.StringAttribute{
				Description: schemaDescriptions["project_id"],
				Required:    true,
				PlanModifiers: []planmodifier.String{
					stringplanmodifier.RequiresReplace(),
				},
				Validators: []validator.String{
					validate.UUID(),
					validate.NoSeparator(),
				},
			},
			"acl": schema.ListAttribute{
				Description: schemaDescriptions["acl"],
				ElementType: types.StringType,
				Optional:    true,
			},
			"created": schema.StringAttribute{
				Description: schemaDescriptions["created"],
				Computed:    true,
			},
			"datasource_url": schema.StringAttribute{
				Description: schemaDescriptions["datasource_url"],
				Computed:    true,
			},
			"description": schema.StringAttribute{
				Description: schemaDescriptions["description"],
				Optional:    true,
			},
			"display_name": schema.StringAttribute{
				Description: schemaDescriptions["display_name"],
				Required:    true,
			},
			"ingest_otlp_url": schema.StringAttribute{
				Description: schemaDescriptions["ingest_otlp_url"],
				Computed:    true,
			},
			"ingest_url": schema.StringAttribute{
				Description: schemaDescriptions["ingest_url"],
				Computed:    true,
			},
			"query_range_url": schema.StringAttribute{
				Description: schemaDescriptions["query_range_url"],
				Computed:    true,
			},
			"query_url": schema.StringAttribute{
				Description: schemaDescriptions["query_url"],
				Computed:    true,
			},
			"retention_days": schema.Int32Attribute{
				Description: schemaDescriptions["retention_days"],
				Required:    true,
			},
			"status": schema.StringAttribute{
				Description: schemaDescriptions["status"],
				Computed:    true,
			},
		},
	}
}

func (r *logsInstanceResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) { // nolint:gocritic // function signature required by Terraform
	var model Model
	diags := req.Plan.Get(ctx, &model)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {
		return
	}

	ctx = core.InitProviderContext(ctx)

	projectId := model.ProjectID.ValueString()
	region := model.Region.ValueString()
	ctx = tflog.SetField(ctx, "project_id", projectId)
	ctx = tflog.SetField(ctx, "region", region)

	payload, err := toCreatePayload(ctx, resp.Diagnostics, &model)
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating Logs Instance", fmt.Sprintf("Creating API payload: %v", err))
		return
	}

	regionId := r.providerData.GetRegionWithOverride(model.Region)
	ctx = tflog.SetField(ctx, "region", regionId)
	createResp, err := r.client.DefaultAPI.CreateLogsInstance(ctx, projectId, regionId).CreateLogsInstancePayload(*payload).Execute()
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating Logs Instance", fmt.Sprintf("Calling API: %v", err))
		return
	}

	ctx = core.LogResponse(ctx)

	if createResp == nil || createResp.Id == "" {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating Logs Instance", "Create API response: Incomplete response (id missing)")
		return
	}
	instanceId := createResp.Id
	// Write id attributes to state before polling via the wait handler - just in case anything goes wrong during the wait handler
	ctx = tfutils.SetAndLogStateFields(ctx, &resp.Diagnostics, &resp.State, map[string]any{
		"project_id":  projectId,
		"region":      region,
		"instance_id": instanceId,
	})
	if resp.Diagnostics.HasError() {
		return
	}

	waitResp, err := wait.CreateLogsInstanceWaitHandler(ctx, r.client.DefaultAPI, projectId, regionId, createResp.Id).WaitWithContext(ctx)
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating Logs Instance", fmt.Sprintf("Waiting for Logs Instance to become active: %v", err))
		return
	}

	err = mapFields(ctx, waitResp, &model)
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error creating Logs Instance", fmt.Sprintf("Processing response: %v", err))
		return
	}
	diags = resp.State.Set(ctx, model)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {
		return
	}
	tflog.Info(ctx, "Logs instance created")
}

func (r *logsInstanceResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
	var model Model
	diags := req.State.Get(ctx, &model)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {
		return
	}

	ctx = core.InitProviderContext(ctx)

	projectID := model.ProjectID.ValueString()
	region := model.Region.ValueString()
	instanceID := model.InstanceID.ValueString()

	ctx = tflog.SetField(ctx, "project_id", projectID)
	ctx = tflog.SetField(ctx, "region", region)
	ctx = tflog.SetField(ctx, "instance_id", instanceID)

	instanceResponse, err := r.client.DefaultAPI.GetLogsInstance(ctx, projectID, region, instanceID).Execute()
	if err != nil {
		var oapiErr *oapierror.GenericOpenAPIError
		ok := errors.As(err, &oapiErr)
		if ok && oapiErr.StatusCode == http.StatusNotFound {
			resp.State.RemoveResource(ctx)
			return
		}
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading logs instance", fmt.Sprintf("Calling API: %v", err))
		return
	}
	ctx = core.LogResponse(ctx)

	err = mapFields(ctx, instanceResponse, &model)
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading logs instance", fmt.Sprintf("Processing response: %v", err))
		return
	}
	diags = resp.State.Set(ctx, model)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {
		return
	}
	tflog.Info(ctx, "Logs Instance read", map[string]any{
		"instance_id": instanceID,
	})
}

func (r *logsInstanceResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) { // nolint:gocritic // function signature required by Terraform
	var model Model
	diags := req.Plan.Get(ctx, &model)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {
		return
	}

	ctx = core.InitProviderContext(ctx)

	projectID := model.ProjectID.ValueString()
	region := model.Region.ValueString()
	instanceID := model.InstanceID.ValueString()

	ctx = tflog.SetField(ctx, "project_id", projectID)
	ctx = tflog.SetField(ctx, "region", region)
	ctx = tflog.SetField(ctx, "instance_id", instanceID)

	payload, err := toUpdatePayload(ctx, resp.Diagnostics, &model)
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating Logs Instance", fmt.Sprintf("Creating API payload: %v", err))
		return
	}

	updateResp, err := r.client.DefaultAPI.UpdateLogsInstance(ctx, projectID, region, instanceID).UpdateLogsInstancePayload(*payload).Execute()
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating Logs Instance", fmt.Sprintf("Calling API: %v", err))
		return
	}

	ctx = core.LogResponse(ctx)

	err = mapFields(ctx, updateResp, &model)
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error updating Logs Instance", fmt.Sprintf("Processing response: %v", err))
		return
	}

	diags = resp.State.Set(ctx, model)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {
		return
	}
	tflog.Info(ctx, "Logs Instance updated", map[string]any{
		"instance_id": instanceID,
	})
}

func (r *logsInstanceResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) { // nolint:gocritic // function signature required by Terraform
	var model Model
	diags := req.State.Get(ctx, &model)
	resp.Diagnostics.Append(diags...)
	if resp.Diagnostics.HasError() {
		return
	}

	ctx = core.InitProviderContext(ctx)

	projectID := model.ProjectID.ValueString()
	region := model.Region.ValueString()
	instanceID := model.InstanceID.ValueString()

	ctx = tflog.SetField(ctx, "project_id", projectID)
	ctx = tflog.SetField(ctx, "region", region)
	ctx = tflog.SetField(ctx, "instance_id", instanceID)

	err := r.client.DefaultAPI.DeleteLogsInstance(ctx, projectID, region, instanceID).Execute()
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting Logs Instance", fmt.Sprintf("Calling API: %v", err))
		return
	}

	ctx = core.LogResponse(ctx)

	_, err = wait.DeleteLogsInstanceWaitHandler(ctx, r.client.DefaultAPI, projectID, region, instanceID).WaitWithContext(ctx)
	if err != nil {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error deleting Logs Instance", fmt.Sprintf("Waiting for Logs Instance to be deleted: %v", err))
		return
	}

	tflog.Info(ctx, "Logs Instance deleted")
}

func (r *logsInstanceResource) ImportState(ctx context.Context, req resource.ImportStateRequest, resp *resource.ImportStateResponse) {
	idParts := strings.Split(req.ID, core.Separator)
	if len(idParts) != 3 || idParts[0] == "" || idParts[1] == "" || idParts[2] == "" {
		core.LogAndAddError(ctx, &resp.Diagnostics, "Error importing Logs Instance", fmt.Sprintf("Invalid import ID %q: expected format is `project_id`,`region`,`instance_id`", req.ID))
		return
	}

	ctx = tfutils.SetAndLogStateFields(ctx, &resp.Diagnostics, &resp.State, map[string]any{
		"project_id":  idParts[0],
		"region":      idParts[1],
		"instance_id": idParts[2],
	})
	tflog.Info(ctx, "Logs Instance state imported")
}

func toCreatePayload(ctx context.Context, diagnostics diag.Diagnostics, model *Model) (*logs.CreateLogsInstancePayload, error) {
	if model == nil {
		return nil, fmt.Errorf("missing model")
	}

	payload := &logs.CreateLogsInstancePayload{
		Description:   conversion.StringValueToPointer(model.Description),
		DisplayName:   model.DisplayName.ValueString(),
		RetentionDays: model.RetentionDays.ValueInt32(),
	}

	if !(model.ACL.IsNull() || model.ACL.IsUnknown()) {
		var acl []string
		aclDiags := model.ACL.ElementsAs(ctx, &acl, false)
		diagnostics.Append(aclDiags...)
		if !aclDiags.HasError() {
			payload.Acl = acl
		}
	}

	return payload, nil
}

func mapFields(ctx context.Context, instance *logs.LogsInstance, model *Model) error {
	if instance == nil {
		return fmt.Errorf("instance is nil")
	}
	if model == nil {
		return fmt.Errorf("model is nil")
	}
	var instanceID string
	if model.InstanceID.ValueString() != "" {
		instanceID = model.InstanceID.ValueString()
	} else if instance.Id != "" {
		instanceID = instance.Id
	} else {
		return fmt.Errorf("instance id not present")
	}

	aclList := types.ListNull(types.StringType)
	var diags diag.Diagnostics
	if len(instance.Acl) > 0 {
		aclList, diags = types.ListValueFrom(ctx, types.StringType, instance.Acl)
		if diags.HasError() {
			return fmt.Errorf("mapping ACL: %w", core.DiagsToError(diags))
		}
	}

	model.ID = tfutils.BuildInternalTerraformId(model.ProjectID.ValueString(), model.Region.ValueString(), instanceID)
	model.InstanceID = types.StringValue(instanceID)
	model.ACL = aclList
	model.Created = types.StringValue(instance.Created.String())
	model.DatasourceURL = types.StringPointerValue(instance.DatasourceUrl)
	model.Description = types.StringPointerValue(instance.Description)
	model.DisplayName = types.StringValue(instance.DisplayName)
	model.IngestOTLPURL = types.StringPointerValue(instance.IngestOtlpUrl)
	model.IngestURL = types.StringPointerValue(instance.IngestUrl)
	model.QueryRangeURL = types.StringPointerValue(instance.QueryRangeUrl)
	model.QueryURL = types.StringPointerValue(instance.QueryUrl)
	model.RetentionDays = types.Int32Value(instance.RetentionDays)
	model.Status = types.StringValue(instance.Status)

	return nil
}

func toUpdatePayload(ctx context.Context, diagnostics diag.Diagnostics, model *Model) (*logs.UpdateLogsInstancePayload, error) {
	if model == nil {
		return nil, fmt.Errorf("missing model")
	}

	payload := &logs.UpdateLogsInstancePayload{
		Description:   conversion.StringValueToPointer(model.Description),
		DisplayName:   conversion.StringValueToPointer(model.DisplayName),
		RetentionDays: model.RetentionDays.ValueInt32Pointer(),
	}

	if !(model.ACL.IsNull() || model.ACL.IsUnknown()) {
		var acl []string
		aclDiags := model.ACL.ElementsAs(ctx, &acl, false)
		diagnostics.Append(aclDiags...)
		if !aclDiags.HasError() {
			payload.Acl = acl
		}
	}

	return payload, nil
}