cloudstack/resource_cloudstack_limits.go - cloudstack-terraform-provider - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one
 // or more contributor license agreements.  See the NOTICE file
 // distributed with this work for additional information
 // regarding copyright ownership.  The ASF licenses this file
 // to you under the Apache License, Version 2.0 (the
 // "License"); you may not use this file except in compliance
 // with the License.  You may obtain a copy of the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing,
 // software distributed under the License is distributed on an
 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 // KIND, either express or implied.  See the License for the
 // specific language governing permissions and limitations
 // under the License.
 //

 package cloudstack

 import (
 	"context"
 	"fmt"
 	"log"
 	"strconv"
 	"strings"

 	"github.com/apache/cloudstack-go/v2/cloudstack"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
 )

 // resourceTypeMap maps string resource types to their integer values
 var resourceTypeMap = map[string]int{
 	"instance":         0,
 	"ip":               1,
 	"volume":           2,
 	"snapshot":         3,
 	"template":         4,
 	"project":          5,
 	"network":          6,
 	"vpc":              7,
 	"cpu":              8,
 	"memory":           9,
 	"primarystorage":   10,
 	"secondarystorage": 11,
 }

 func resourceCloudStackLimits() *schema.Resource {
 	return &schema.Resource{
 		Read:   resourceCloudStackLimitsRead,
 		Update: resourceCloudStackLimitsUpdate,
 		Create: resourceCloudStackLimitsCreate,
 		Delete: resourceCloudStackLimitsDelete,
 		Schema: map[string]*schema.Schema{
 			"type": {
 				Type:     schema.TypeString,
 				Required: true,
 				ForceNew: true,
 				ValidateFunc: validation.StringInSlice([]string{
 					"instance", "ip", "volume", "snapshot", "template", "project", "network", "vpc",
 					"cpu", "memory", "primarystorage", "secondarystorage",
 				}, false), // false disables case-insensitive matching
 				Description: "The type of resource to update the limits. Available types are: " +
 					"instance, ip, volume, snapshot, template, project, network, vpc, cpu, memory, " +
 					"primarystorage, secondarystorage",
 			},
 			"account": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				ForceNew:    true,
 				Description: "Update resource for a specified account. Must be used with the domain_id parameter.",
 			},
 			"domain_id": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				ForceNew:    true,
 				Description: "Update resource limits for all accounts in specified domain. If used with the account parameter, updates resource limits for a specified account in specified domain.",
 			},
 			"max": {
 				Type:        schema.TypeInt,
 				Optional:    true,
 				Description: "Maximum resource limit. Use -1 for unlimited resource limit. A value of 0 means zero resources are allowed, though the CloudStack API may return -1 for a limit set to 0.",
 			},
 			"configured_max": {
 				Type:        schema.TypeInt,
 				Computed:    true,
 				Description: "Internal field to track the originally configured max value to distinguish between 0 and -1 when CloudStack returns -1.",
 			},
 			"project": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				ForceNew:    true,
 				Description: "Update resource limits for project.",
 			},
 		},
 		Importer: &schema.ResourceImporter{
 			StateContext: resourceCloudStackLimitsImport,
 		},
 	}
 }

 // resourceCloudStackLimitsImport parses composite import IDs and sets resource fields accordingly.
 func resourceCloudStackLimitsImport(ctx context.Context, d *schema.ResourceData, meta interface{}) ([]*schema.ResourceData, error) {
 	// Expected formats:
 	// - type-account-accountname-domain_id (for account-specific limits)
 	// - type-project-projectid (for project-specific limits)
 	// - type-domain-domain_id (for domain-specific limits)

 	log.Printf("[DEBUG] Importing resource with ID: %s", d.Id())

 	// First, extract the resource type which is always the first part
 	idParts := strings.SplitN(d.Id(), "-", 2)
 	if len(idParts) < 2 {
 		return nil, fmt.Errorf("unexpected import ID format (%q), expected type-account-accountname-domain_id, type-domain-domain_id, or type-project-projectid", d.Id())
 	}

 	// Parse the resource type
 	typeInt, err := strconv.Atoi(idParts[0])
 	if err != nil {
 		return nil, fmt.Errorf("invalid type value in import ID: %s", idParts[0])
 	}

 	// Find the string representation for this numeric type
 	var typeStr string
 	for k, v := range resourceTypeMap {
 		if v == typeInt {
 			typeStr = k
 			break
 		}
 	}
 	if typeStr == "" {
 		return nil, fmt.Errorf("unknown type value in import ID: %d", typeInt)
 	}
 	if err := d.Set("type", typeStr); err != nil {
 		return nil, err
 	}

 	// Get the original resource ID from the state
 	originalID := d.Id()
 	log.Printf("[DEBUG] Original import ID: %s", originalID)

 	// Instead of trying to parse the complex ID, let's create a new resource
 	// and read it from the API to get the correct values
 	cs := meta.(*cloudstack.CloudStackClient)

 	// Create a new parameter struct for listing resource limits
 	p := cs.Limit.NewListResourceLimitsParams()
 	p.SetResourcetype(typeInt)

 	// Try to determine the resource scope from the ID format
 	remainingID := idParts[1]

 	// Extract the resource scope from the ID
 	if strings.HasPrefix(remainingID, "domain-") {
 		// It's a domain-specific limit
 		log.Printf("[DEBUG] Detected domain-specific limit")
 		// We'll use the Read function to get the domain ID from the state
 		// after setting a temporary ID
 		d.SetId(originalID)
 		return []*schema.ResourceData{d}, nil
 	} else if strings.HasPrefix(remainingID, "project-") {
 		// It's a project-specific limit
 		log.Printf("[DEBUG] Detected project-specific limit")
 		// We'll use the Read function to get the project ID from the state
 		// after setting a temporary ID
 		d.SetId(originalID)
 		return []*schema.ResourceData{d}, nil
 	} else if strings.HasPrefix(remainingID, "account-") {
 		// It's an account-specific limit
 		log.Printf("[DEBUG] Detected account-specific limit")
 		// We'll use the Read function to get the account and domain ID from the state
 		// after setting a temporary ID
 		d.SetId(originalID)
 		return []*schema.ResourceData{d}, nil
 	} else {
 		// For backward compatibility, assume it's a global limit
 		log.Printf("[DEBUG] Detected global limit")
 		d.SetId(originalID)
 		return []*schema.ResourceData{d}, nil
 	}
 }

 // getResourceType gets the resource type from the type field
 func getResourceType(d *schema.ResourceData) (int, error) {
 	// Check if type is set
 	if v, ok := d.GetOk("type"); ok {
 		typeStr := v.(string)
 		if resourcetype, ok := resourceTypeMap[typeStr]; ok {
 			return resourcetype, nil
 		}
 		return 0, fmt.Errorf("invalid type value: %s", typeStr)
 	}

 	return 0, fmt.Errorf("type must be specified")
 }

 func resourceCloudStackLimitsCreate(d *schema.ResourceData, meta interface{}) error {
 	cs := meta.(*cloudstack.CloudStackClient)

 	resourcetype, err := getResourceType(d)
 	if err != nil {
 		return err
 	}

 	account := d.Get("account").(string)
 	domain_id := d.Get("domain_id").(string)
 	projectid := d.Get("project").(string)

 	// Validate account and domain parameters
 	if account != "" && domain_id == "" {
 		return fmt.Errorf("domain_id is required when account is specified")
 	}

 	// Create a new parameter struct
 	p := cs.Limit.NewUpdateResourceLimitParams(resourcetype)
 	if account != "" {
 		p.SetAccount(account)
 	}
 	if domain_id != "" {
 		p.SetDomainid(domain_id)
 	}
 	// Check for max value - need to handle zero values explicitly
 	maxVal := d.Get("max")
 	if maxVal != nil {
 		maxIntVal := maxVal.(int)
 		log.Printf("[DEBUG] Setting max value to %d", maxIntVal)
 		p.SetMax(int64(maxIntVal))

 		// Store the original configured value for later reference
 		// This helps the Read function distinguish between 0 and -1 when CloudStack returns -1
 		if err := d.Set("configured_max", maxIntVal); err != nil {
 			return fmt.Errorf("error storing configured max value: %w", err)
 		}
 	} else {
 		log.Printf("[DEBUG] No max value found in configuration during Create")
 	}
 	if projectid != "" {
 		p.SetProjectid(projectid)
 	}

 	log.Printf("[DEBUG] Updating Resource Limit for type %d", resourcetype)
 	_, err = cs.Limit.UpdateResourceLimit(p)

 	if err != nil {
 		return fmt.Errorf("Error creating resource limit: %s", err)
 	}

 	// Generate a unique ID based on the parameters
 	id := generateResourceID(resourcetype, account, domain_id, projectid)
 	d.SetId(id)

 	return resourceCloudStackLimitsRead(d, meta)
 }

 // generateResourceID creates a unique ID for the resource based on its parameters
 func generateResourceID(resourcetype int, account, domain_id, projectid string) string {
 	if projectid != "" {
 		return fmt.Sprintf("%d-project-%s", resourcetype, projectid)
 	}

 	if account != "" && domain_id != "" {
 		return fmt.Sprintf("%d-account-%s-%s", resourcetype, account, domain_id)
 	}

 	if domain_id != "" {
 		return fmt.Sprintf("%d-domain-%s", resourcetype, domain_id)
 	}

 	return fmt.Sprintf("%d", resourcetype)
 }

 func resourceCloudStackLimitsRead(d *schema.ResourceData, meta interface{}) error {
 	cs := meta.(*cloudstack.CloudStackClient)

 	// Get the resourcetype from the type field
 	resourcetype, err := getResourceType(d)
 	if err != nil {
 		// If there's an error getting the type, try to extract it from the ID
 		idParts := strings.Split(d.Id(), "-")
 		if len(idParts) > 0 {
 			if rt, err := strconv.Atoi(idParts[0]); err == nil {
 				resourcetype = rt
 				// Find the string representation for this numeric type
 				for typeStr, typeVal := range resourceTypeMap {
 					if typeVal == rt {
 						if err := d.Set("type", typeStr); err != nil {
 							return fmt.Errorf("error setting type: %s", err)
 						}
 						break
 					}
 				}

 				// Handle different ID formats
 				if len(idParts) >= 3 {
 					if idParts[1] == "domain" {
 						// Format: resourcetype-domain-domain_id
 						if err := d.Set("domain_id", idParts[2]); err != nil {
 							return fmt.Errorf("error setting domain_id: %s", err)
 						}
 					} else if idParts[1] == "project" {
 						// Format: resourcetype-project-projectid
 						if err := d.Set("project", idParts[2]); err != nil {
 							return fmt.Errorf("error setting project: %s", err)
 						}
 					} else if idParts[1] == "account" && len(idParts) >= 4 {
 						// Format: resourcetype-account-account-domain_id
 						if err := d.Set("account", idParts[2]); err != nil {
 							return fmt.Errorf("error setting account: %s", err)
 						}
 						if err := d.Set("domain_id", idParts[3]); err != nil {
 							return fmt.Errorf("error setting domain_id: %s", err)
 						}
 					}
 				}
 			}
 		}
 	}

 	account := d.Get("account").(string)
 	domain_id := d.Get("domain_id").(string)
 	projectid := d.Get("project").(string)

 	// Create a new parameter struct
 	p := cs.Limit.NewListResourceLimitsParams()
 	p.SetResourcetype(resourcetype)
 	if account != "" {
 		p.SetAccount(account)
 	}
 	if domain_id != "" {
 		p.SetDomainid(domain_id)
 	}
 	if projectid != "" {
 		p.SetProjectid(projectid)
 	}

 	// Retrieve the resource limits
 	l, err := cs.Limit.ListResourceLimits(p)
 	if err != nil {
 		return fmt.Errorf("error retrieving resource limits: %s", err)
 	}

 	if l.Count == 0 {
 		log.Printf("[DEBUG] Resource limit not found")
 		d.SetId("")
 		return nil
 	}

 	// Get the first (and should be only) limit from the results
 	limit := l.ResourceLimits[0]

 	// Handle the max value - CloudStack may return -1 for both unlimited and zero limits
 	// We need to preserve the original value from the configuration when possible
 	log.Printf("[DEBUG] CloudStack returned max value: %d", limit.Max)
 	if limit.Max == -1 {
 		// CloudStack returns -1 for both unlimited and zero limits
 		// Check if we have the originally configured value stored
 		if configuredMax, hasConfiguredMax := d.GetOk("configured_max"); hasConfiguredMax {
 			configuredValue := configuredMax.(int)
 			log.Printf("[DEBUG] Found configured max value: %d, using it", configuredValue)
 			// Use the originally configured value (0 for zero limit, -1 for unlimited)
 			if err := d.Set("max", configuredValue); err != nil {
 				return fmt.Errorf("error setting max to configured value %d: %w", configuredValue, err)
 			}
 		} else {
 			log.Printf("[DEBUG] No configured max value found, treating -1 as unlimited")
 			// If no configured value is stored, treat -1 as unlimited
 			if err := d.Set("max", -1); err != nil {
 				return fmt.Errorf("error setting max to unlimited (-1): %w", err)
 			}
 		}
 	} else {
 		log.Printf("[DEBUG] Using positive max value from API: %d", limit.Max)
 		// For any positive value, use it directly from the API
 		if err := d.Set("max", int(limit.Max)); err != nil {
 			return fmt.Errorf("error setting max: %w", err)
 		}
 	}

 	// Preserve original type configuration if it exists
 	if typeValue, ok := d.GetOk("type"); ok {
 		if err := d.Set("type", typeValue.(string)); err != nil {
 			return fmt.Errorf("error setting type: %w", err)
 		}
 	}

 	return nil
 }

 func resourceCloudStackLimitsUpdate(d *schema.ResourceData, meta interface{}) error {
 	cs := meta.(*cloudstack.CloudStackClient)

 	resourcetype, err := getResourceType(d)
 	if err != nil {
 		return err
 	}

 	account := d.Get("account").(string)
 	domain_id := d.Get("domain_id").(string)
 	projectid := d.Get("project").(string)

 	// Create a new parameter struct
 	p := cs.Limit.NewUpdateResourceLimitParams(resourcetype)
 	if account != "" {
 		p.SetAccount(account)
 	}
 	if domain_id != "" {
 		p.SetDomainid(domain_id)
 	}
 	if maxVal, ok := d.GetOk("max"); ok {
 		maxIntVal := maxVal.(int)
 		log.Printf("[DEBUG] Setting max value to %d", maxIntVal)
 		p.SetMax(int64(maxIntVal))

 		// Store the original configured value for later reference
 		// This helps the Read function distinguish between 0 and -1 when CloudStack returns -1
 		log.Printf("[DEBUG] Storing configured max value in update: %d", maxIntVal)
 		if err := d.Set("configured_max", maxIntVal); err != nil {
 			return fmt.Errorf("error storing configured max value: %w", err)
 		}
 	}
 	if projectid != "" {
 		p.SetProjectid(projectid)
 	}

 	log.Printf("[DEBUG] Updating Resource Limit for type %d", resourcetype)
 	_, err = cs.Limit.UpdateResourceLimit(p)

 	if err != nil {
 		return fmt.Errorf("Error updating resource limit: %s", err)
 	}

 	return resourceCloudStackLimitsRead(d, meta)
 }

 func resourceCloudStackLimitsDelete(d *schema.ResourceData, meta interface{}) error {
 	cs := meta.(*cloudstack.CloudStackClient)

 	resourcetype, err := getResourceType(d)
 	if err != nil {
 		return err
 	}

 	account := d.Get("account").(string)
 	domain_id := d.Get("domain_id").(string)
 	projectid := d.Get("project").(string)

 	// Create a new parameter struct
 	p := cs.Limit.NewUpdateResourceLimitParams(resourcetype)
 	if account != "" {
 		p.SetAccount(account)
 	}
 	if domain_id != "" {
 		p.SetDomainid(domain_id)
 	}
 	if projectid != "" {
 		p.SetProjectid(projectid)
 	}
 	p.SetMax(-1) // Set to -1 to remove the limit

 	log.Printf("[DEBUG] Removing Resource Limit for type %d", resourcetype)
 	_, err = cs.Limit.UpdateResourceLimit(p)

 	if err != nil {
 		return fmt.Errorf("Error removing Resource Limit: %s", err)
 	}

 	d.SetId("")

 	return nil
 }
	// Licensed to the Apache Software Foundation (ASF) under one
	// or more contributor license agreements. See the NOTICE file
	// distributed with this work for additional information
	// regarding copyright ownership. The ASF licenses this file
	// to you under the Apache License, Version 2.0 (the
	// "License"); you may not use this file except in compliance
	// with the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing,
	// software distributed under the License is distributed on an
	// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	// KIND, either express or implied. See the License for the
	// specific language governing permissions and limitations
	// under the License.
	//

	package cloudstack

	import (
	"context"
	"fmt"
	"log"
	"strconv"
	"strings"

	"github.com/apache/cloudstack-go/v2/cloudstack"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
	)

	// resourceTypeMap maps string resource types to their integer values
	var resourceTypeMap = map[string]int{
	"instance": 0,
	"ip": 1,
	"volume": 2,
	"snapshot": 3,
	"template": 4,
	"project": 5,
	"network": 6,
	"vpc": 7,
	"cpu": 8,
	"memory": 9,
	"primarystorage": 10,
	"secondarystorage": 11,
	}

	func resourceCloudStackLimits() *schema.Resource {
	return &schema.Resource{
	Read: resourceCloudStackLimitsRead,
	Update: resourceCloudStackLimitsUpdate,
	Create: resourceCloudStackLimitsCreate,
	Delete: resourceCloudStackLimitsDelete,
	Schema: map[string]*schema.Schema{
	"type": {
	Type: schema.TypeString,
	Required: true,
	ForceNew: true,
	ValidateFunc: validation.StringInSlice([]string{
	"instance", "ip", "volume", "snapshot", "template", "project", "network", "vpc",
	"cpu", "memory", "primarystorage", "secondarystorage",
	}, false), // false disables case-insensitive matching
	Description: "The type of resource to update the limits. Available types are: " +
	"instance, ip, volume, snapshot, template, project, network, vpc, cpu, memory, " +
	"primarystorage, secondarystorage",
	},
	"account": {
	Type: schema.TypeString,
	Optional: true,
	ForceNew: true,
	Description: "Update resource for a specified account. Must be used with the domain_id parameter.",
	},
	"domain_id": {
	Type: schema.TypeString,
	Optional: true,
	ForceNew: true,
	Description: "Update resource limits for all accounts in specified domain. If used with the account parameter, updates resource limits for a specified account in specified domain.",
	},
	"max": {
	Type: schema.TypeInt,
	Optional: true,
	Description: "Maximum resource limit. Use -1 for unlimited resource limit. A value of 0 means zero resources are allowed, though the CloudStack API may return -1 for a limit set to 0.",
	},
	"configured_max": {
	Type: schema.TypeInt,
	Computed: true,
	Description: "Internal field to track the originally configured max value to distinguish between 0 and -1 when CloudStack returns -1.",
	},
	"project": {
	Type: schema.TypeString,
	Optional: true,
	ForceNew: true,
	Description: "Update resource limits for project.",
	},
	},
	Importer: &schema.ResourceImporter{
	StateContext: resourceCloudStackLimitsImport,
	},
	}
	}

	// resourceCloudStackLimitsImport parses composite import IDs and sets resource fields accordingly.
	func resourceCloudStackLimitsImport(ctx context.Context, d schema.ResourceData, meta interface{}) ([]schema.ResourceData, error) {
	// Expected formats:
	// - type-account-accountname-domain_id (for account-specific limits)
	// - type-project-projectid (for project-specific limits)
	// - type-domain-domain_id (for domain-specific limits)

	log.Printf("[DEBUG] Importing resource with ID: %s", d.Id())

	// First, extract the resource type which is always the first part
	idParts := strings.SplitN(d.Id(), "-", 2)
	if len(idParts) < 2 {
	return nil, fmt.Errorf("unexpected import ID format (%q), expected type-account-accountname-domain_id, type-domain-domain_id, or type-project-projectid", d.Id())
	}

	// Parse the resource type
	typeInt, err := strconv.Atoi(idParts[0])
	if err != nil {
	return nil, fmt.Errorf("invalid type value in import ID: %s", idParts[0])
	}

	// Find the string representation for this numeric type
	var typeStr string
	for k, v := range resourceTypeMap {
	if v == typeInt {
	typeStr = k
	break
	}
	}
	if typeStr == "" {
	return nil, fmt.Errorf("unknown type value in import ID: %d", typeInt)
	}
	if err := d.Set("type", typeStr); err != nil {
	return nil, err
	}

	// Get the original resource ID from the state
	originalID := d.Id()
	log.Printf("[DEBUG] Original import ID: %s", originalID)

	// Instead of trying to parse the complex ID, let's create a new resource
	// and read it from the API to get the correct values
	cs := meta.(*cloudstack.CloudStackClient)

	// Create a new parameter struct for listing resource limits
	p := cs.Limit.NewListResourceLimitsParams()
	p.SetResourcetype(typeInt)

	// Try to determine the resource scope from the ID format
	remainingID := idParts[1]

	// Extract the resource scope from the ID
	if strings.HasPrefix(remainingID, "domain-") {
	// It's a domain-specific limit
	log.Printf("[DEBUG] Detected domain-specific limit")
	// We'll use the Read function to get the domain ID from the state
	// after setting a temporary ID
	d.SetId(originalID)
	return []*schema.ResourceData{d}, nil
	} else if strings.HasPrefix(remainingID, "project-") {
	// It's a project-specific limit
	log.Printf("[DEBUG] Detected project-specific limit")
	// We'll use the Read function to get the project ID from the state
	// after setting a temporary ID
	d.SetId(originalID)
	return []*schema.ResourceData{d}, nil
	} else if strings.HasPrefix(remainingID, "account-") {
	// It's an account-specific limit
	log.Printf("[DEBUG] Detected account-specific limit")
	// We'll use the Read function to get the account and domain ID from the state
	// after setting a temporary ID
	d.SetId(originalID)
	return []*schema.ResourceData{d}, nil
	} else {
	// For backward compatibility, assume it's a global limit
	log.Printf("[DEBUG] Detected global limit")
	d.SetId(originalID)
	return []*schema.ResourceData{d}, nil
	}
	}

	// getResourceType gets the resource type from the type field
	func getResourceType(d *schema.ResourceData) (int, error) {
	// Check if type is set
	if v, ok := d.GetOk("type"); ok {
	typeStr := v.(string)
	if resourcetype, ok := resourceTypeMap[typeStr]; ok {
	return resourcetype, nil
	}
	return 0, fmt.Errorf("invalid type value: %s", typeStr)
	}

	return 0, fmt.Errorf("type must be specified")
	}

	func resourceCloudStackLimitsCreate(d *schema.ResourceData, meta interface{}) error {
	cs := meta.(*cloudstack.CloudStackClient)

	resourcetype, err := getResourceType(d)
	if err != nil {
	return err
	}

	account := d.Get("account").(string)
	domain_id := d.Get("domain_id").(string)
	projectid := d.Get("project").(string)

	// Validate account and domain parameters
	if account != "" && domain_id == "" {
	return fmt.Errorf("domain_id is required when account is specified")
	}

	// Create a new parameter struct
	p := cs.Limit.NewUpdateResourceLimitParams(resourcetype)
	if account != "" {
	p.SetAccount(account)
	}
	if domain_id != "" {
	p.SetDomainid(domain_id)
	}
	// Check for max value - need to handle zero values explicitly
	maxVal := d.Get("max")
	if maxVal != nil {
	maxIntVal := maxVal.(int)
	log.Printf("[DEBUG] Setting max value to %d", maxIntVal)
	p.SetMax(int64(maxIntVal))

	// Store the original configured value for later reference
	// This helps the Read function distinguish between 0 and -1 when CloudStack returns -1
	if err := d.Set("configured_max", maxIntVal); err != nil {
	return fmt.Errorf("error storing configured max value: %w", err)
	}
	} else {
	log.Printf("[DEBUG] No max value found in configuration during Create")
	}
	if projectid != "" {
	p.SetProjectid(projectid)
	}

	log.Printf("[DEBUG] Updating Resource Limit for type %d", resourcetype)
	_, err = cs.Limit.UpdateResourceLimit(p)

	if err != nil {
	return fmt.Errorf("Error creating resource limit: %s", err)
	}

	// Generate a unique ID based on the parameters
	id := generateResourceID(resourcetype, account, domain_id, projectid)
	d.SetId(id)

	return resourceCloudStackLimitsRead(d, meta)
	}

	// generateResourceID creates a unique ID for the resource based on its parameters
	func generateResourceID(resourcetype int, account, domain_id, projectid string) string {
	if projectid != "" {
	return fmt.Sprintf("%d-project-%s", resourcetype, projectid)
	}

	if account != "" && domain_id != "" {
	return fmt.Sprintf("%d-account-%s-%s", resourcetype, account, domain_id)
	}

	if domain_id != "" {
	return fmt.Sprintf("%d-domain-%s", resourcetype, domain_id)
	}

	return fmt.Sprintf("%d", resourcetype)
	}

	func resourceCloudStackLimitsRead(d *schema.ResourceData, meta interface{}) error {
	cs := meta.(*cloudstack.CloudStackClient)

	// Get the resourcetype from the type field
	resourcetype, err := getResourceType(d)
	if err != nil {
	// If there's an error getting the type, try to extract it from the ID
	idParts := strings.Split(d.Id(), "-")
	if len(idParts) > 0 {
	if rt, err := strconv.Atoi(idParts[0]); err == nil {
	resourcetype = rt
	// Find the string representation for this numeric type
	for typeStr, typeVal := range resourceTypeMap {
	if typeVal == rt {
	if err := d.Set("type", typeStr); err != nil {
	return fmt.Errorf("error setting type: %s", err)
	}
	break
	}
	}

	// Handle different ID formats
	if len(idParts) >= 3 {
	if idParts[1] == "domain" {
	// Format: resourcetype-domain-domain_id
	if err := d.Set("domain_id", idParts[2]); err != nil {
	return fmt.Errorf("error setting domain_id: %s", err)
	}
	} else if idParts[1] == "project" {
	// Format: resourcetype-project-projectid
	if err := d.Set("project", idParts[2]); err != nil {
	return fmt.Errorf("error setting project: %s", err)
	}
	} else if idParts[1] == "account" && len(idParts) >= 4 {
	// Format: resourcetype-account-account-domain_id
	if err := d.Set("account", idParts[2]); err != nil {
	return fmt.Errorf("error setting account: %s", err)
	}
	if err := d.Set("domain_id", idParts[3]); err != nil {
	return fmt.Errorf("error setting domain_id: %s", err)
	}
	}
	}
	}
	}
	}

	account := d.Get("account").(string)
	domain_id := d.Get("domain_id").(string)
	projectid := d.Get("project").(string)

	// Create a new parameter struct
	p := cs.Limit.NewListResourceLimitsParams()
	p.SetResourcetype(resourcetype)
	if account != "" {
	p.SetAccount(account)
	}
	if domain_id != "" {
	p.SetDomainid(domain_id)
	}
	if projectid != "" {
	p.SetProjectid(projectid)
	}

	// Retrieve the resource limits
	l, err := cs.Limit.ListResourceLimits(p)
	if err != nil {
	return fmt.Errorf("error retrieving resource limits: %s", err)
	}

	if l.Count == 0 {
	log.Printf("[DEBUG] Resource limit not found")
	d.SetId("")
	return nil
	}

	// Get the first (and should be only) limit from the results
	limit := l.ResourceLimits[0]

	// Handle the max value - CloudStack may return -1 for both unlimited and zero limits
	// We need to preserve the original value from the configuration when possible
	log.Printf("[DEBUG] CloudStack returned max value: %d", limit.Max)
	if limit.Max == -1 {
	// CloudStack returns -1 for both unlimited and zero limits
	// Check if we have the originally configured value stored
	if configuredMax, hasConfiguredMax := d.GetOk("configured_max"); hasConfiguredMax {
	configuredValue := configuredMax.(int)
	log.Printf("[DEBUG] Found configured max value: %d, using it", configuredValue)
	// Use the originally configured value (0 for zero limit, -1 for unlimited)
	if err := d.Set("max", configuredValue); err != nil {
	return fmt.Errorf("error setting max to configured value %d: %w", configuredValue, err)
	}
	} else {
	log.Printf("[DEBUG] No configured max value found, treating -1 as unlimited")
	// If no configured value is stored, treat -1 as unlimited
	if err := d.Set("max", -1); err != nil {
	return fmt.Errorf("error setting max to unlimited (-1): %w", err)
	}
	}
	} else {
	log.Printf("[DEBUG] Using positive max value from API: %d", limit.Max)
	// For any positive value, use it directly from the API
	if err := d.Set("max", int(limit.Max)); err != nil {
	return fmt.Errorf("error setting max: %w", err)
	}
	}

	// Preserve original type configuration if it exists
	if typeValue, ok := d.GetOk("type"); ok {
	if err := d.Set("type", typeValue.(string)); err != nil {
	return fmt.Errorf("error setting type: %w", err)
	}
	}

	return nil
	}

	func resourceCloudStackLimitsUpdate(d *schema.ResourceData, meta interface{}) error {
	cs := meta.(*cloudstack.CloudStackClient)

	resourcetype, err := getResourceType(d)
	if err != nil {
	return err
	}

	account := d.Get("account").(string)
	domain_id := d.Get("domain_id").(string)
	projectid := d.Get("project").(string)

	// Create a new parameter struct
	p := cs.Limit.NewUpdateResourceLimitParams(resourcetype)
	if account != "" {
	p.SetAccount(account)
	}
	if domain_id != "" {
	p.SetDomainid(domain_id)
	}
	if maxVal, ok := d.GetOk("max"); ok {
	maxIntVal := maxVal.(int)
	log.Printf("[DEBUG] Setting max value to %d", maxIntVal)
	p.SetMax(int64(maxIntVal))

	// Store the original configured value for later reference
	// This helps the Read function distinguish between 0 and -1 when CloudStack returns -1
	log.Printf("[DEBUG] Storing configured max value in update: %d", maxIntVal)
	if err := d.Set("configured_max", maxIntVal); err != nil {
	return fmt.Errorf("error storing configured max value: %w", err)
	}
	}
	if projectid != "" {
	p.SetProjectid(projectid)
	}

	log.Printf("[DEBUG] Updating Resource Limit for type %d", resourcetype)
	_, err = cs.Limit.UpdateResourceLimit(p)

	if err != nil {
	return fmt.Errorf("Error updating resource limit: %s", err)
	}

	return resourceCloudStackLimitsRead(d, meta)
	}

	func resourceCloudStackLimitsDelete(d *schema.ResourceData, meta interface{}) error {
	cs := meta.(*cloudstack.CloudStackClient)

	resourcetype, err := getResourceType(d)
	if err != nil {
	return err
	}

	account := d.Get("account").(string)
	domain_id := d.Get("domain_id").(string)
	projectid := d.Get("project").(string)

	// Create a new parameter struct
	p := cs.Limit.NewUpdateResourceLimitParams(resourcetype)
	if account != "" {
	p.SetAccount(account)
	}
	if domain_id != "" {
	p.SetDomainid(domain_id)
	}
	if projectid != "" {
	p.SetProjectid(projectid)
	}
	p.SetMax(-1) // Set to -1 to remove the limit

	log.Printf("[DEBUG] Removing Resource Limit for type %d", resourcetype)
	_, err = cs.Limit.UpdateResourceLimit(p)

	if err != nil {
	return fmt.Errorf("Error removing Resource Limit: %s", err)
	}

	d.SetId("")

	return nil
	}