package kvmvm

import (
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation"
	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/constants"
	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/statefuncs"
	"repository.basistech.ru/BASIS/terraform-provider-decort/internal/validators"
)

func resourceComputeResourceV1() *schema.Resource {
	return &schema.Resource{
		Schema: map[string]*schema.Schema{
			"name": {
				Type:        schema.TypeString,
				Required:    true,
				Description: "Name of this compute. Compute names are case sensitive and must be unique in the resource group.",
			},
			"rg_id": {
				Type:         schema.TypeInt,
				Required:     true,
				ValidateFunc: validation.IntAtLeast(1),
				Description:  "ID of the resource group where this compute should be deployed.",
			},
			"driver": {
				Type:         schema.TypeString,
				Required:     true,
				StateFunc:    statefuncs.StateFuncToUpper,
				ValidateFunc: validation.StringInSlice([]string{"SVA_KVM_X86", "KVM_X86"}, false), // observe case while validating
				Description:  "Hardware architecture of this compute instance.",
			},
			"cpu": {
				Type:         schema.TypeInt,
				Required:     true,
				ValidateFunc: validation.IntBetween(1, constants.MAX_CPUS_PER_COMPUTE),
				Description:  "Number of CPUs to allocate to this compute instance.",
			},
			"ram": {
				Type:     schema.TypeInt,
				Required: true,
				ValidateFunc: validation.All(
					validation.IntAtLeast(constants.MIN_RAM_PER_COMPUTE),
					validators.DivisibleBy(constants.RAM_DIVISIBILITY),
				),
				Description: "Amount of RAM in MB to allocate to this compute instance.",
			},
			"image_id": {
				Type:        schema.TypeInt,
				Optional:    true,
				Description: "ID of the OS image to base this compute instance on.",
			},
			"chipset": {
				Type:         schema.TypeString,
				Optional:     true,
				Computed:     true,
				ValidateFunc: validation.StringInSlice([]string{"Q35", "i440fx"}, false), // observe case while validating
				Description:  "Type of the emulated system.",
			},
			"without_boot_disk": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     false,
				Description: "If True, the imageId, bootDisk, sepId, pool parameters are ignored and the compute is created without a boot disk in the stopped state.",
			},
			"boot_disk_size": {
				Type:        schema.TypeInt,
				Optional:    true,
				Computed:    true,
				Description: "This compute instance boot disk size in GB. Make sure it is large enough to accomodate selected OS image.",
			},
			"sep_id": {
				Type:        schema.TypeInt,
				Optional:    true,
				Computed:    true,
				Description: "ID of SEP to create bootDisk on. Uses image's sepId if not set.",
			},
			"pool": {
				Type:        schema.TypeString,
				Optional:    true,
				Computed:    true,
				Description: "Pool to use if sepId is set, can be also empty if needed to be chosen by system.",
			},
			"cloud_init": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: "Optional cloud_init parameters. Applied when creating new compute instance only, ignored in all other cases.",
			},
			"description": {
				Type:        schema.TypeString,
				Optional:    true,
				Computed:    true,
				Description: "Optional text description of this compute instance.",
			},
			"started": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     true,
				Description: "Is compute started.",
			},
			"alt_boot_id": {
				Type:        schema.TypeInt,
				Optional:    true,
				Default:     0,
				Description: "ID of CD-ROM live image to boot",
			},
			"stack_id": {
				Type:        schema.TypeInt,
				Optional:    true,
				Computed:    true,
				Description: "ID of stack to start compute",
			},
			"is": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: "system name",
			},
			"ipa_type": {
				Type:        schema.TypeString,
				Optional:    true,
				Description: "compute purpose",
			},
			"custom_fields": {
				Type:     schema.TypeString,
				Optional: true,
				Computed: true,
			},
			"network": {
				Type:     schema.TypeSet,
				Optional: true,
				MinItems: 1,
				MaxItems: constants.MAX_NETWORKS_PER_COMPUTE,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"net_type": {
							Type:         schema.TypeString,
							Required:     true,
							StateFunc:    statefuncs.StateFuncToUpper,
							ValidateFunc: validation.StringInSlice([]string{"EXTNET", "VINS", "VFNIC", "DPDK"}, false), // observe case while validating
							Description:  "Type of the network for this connection, either EXTNET or VINS.",
						},
						"net_id": {
							Type:        schema.TypeInt,
							Required:    true,
							Description: "ID of the network for this connection.",
						},
						"ip_address": {
							Type:             schema.TypeString,
							Optional:         true,
							Computed:         true,
							DiffSuppressFunc: networkSubresIPAddreDiffSupperss,
							Description:      "Optional IP address to assign to this connection. This IP should belong to the selected network and free for use.",
						},
						"mac": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "MAC address associated with this connection. MAC address is assigned automatically.",
						},
						"weight": {
							Type:        schema.TypeInt,
							Optional:    true,
							Computed:    true,
							Description: "weight the network if you need to sort network list, the smallest attach first. zero or null weight attach last",
						},
						"mtu": {
							Type:     schema.TypeInt,
							Optional: true,
							Computed: true,
							//Default:      1500,
							ValidateFunc: validation.IntBetween(1, 9216),
							Description:  "Maximum transmission unit, used only for DPDK type, must be 1-9216",
						},
					},
				},
				Description: "Optional network connection(s) for this compute. You may specify several network blocks, one for each connection.",
			},

			"libvirt_settings": {
				Type:     schema.TypeSet,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"net_type": {
							Type:         schema.TypeString,
							Required:     true,
							StateFunc:    statefuncs.StateFuncToUpper,
							ValidateFunc: validation.StringInSlice([]string{"VINS", "VFNIC", "DPDK"}, false), // observe case while validating
							Description:  "Type of the network",
						},
						"net_id": {
							Type:        schema.TypeInt,
							Required:    true,
							Description: "ID of the network",
						},
						"txmode": {
							Type:     schema.TypeString,
							Default:  "",
							Optional: true,
						},
						"ioeventfd": {
							Type:     schema.TypeString,
							Default:  "",
							Optional: true,
						},
						"event_idx": {
							Type:     schema.TypeString,
							Default:  "",
							Optional: true,
						},
						"queues": {
							Type:     schema.TypeInt,
							Default:  0,
							Optional: true,
						},
						"rx_queue_size": {
							Type:     schema.TypeInt,
							Default:  0,
							Optional: true,
						},
						"tx_queue_size": {
							Type:     schema.TypeInt,
							Default:  0,
							Optional: true,
						},
					},
				},
				Description: "Configure libvirt virtio interface parameters. You can only delete values locally. Data on the platform cannot be deleted.",
			},

			"affinity_label": {
				Type:        schema.TypeString,
				Optional:    true,
				Computed:    true,
				Description: "Set affinity label for compute",
			},
			"affinity_rules": {
				Type:     schema.TypeList,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"topology": {
							Type:         schema.TypeString,
							Required:     true,
							ValidateFunc: validation.StringInSlice([]string{"node", "compute"}, false),
							Description:  "compute or node, for whom rule applies",
						},
						"policy": {
							Type:         schema.TypeString,
							Required:     true,
							ValidateFunc: validation.StringInSlice([]string{"RECOMMENDED", "REQUIRED"}, false),
							Description:  "RECOMMENDED or REQUIRED, the degree of 'strictness' of this rule",
						},
						"mode": {
							Type:         schema.TypeString,
							Required:     true,
							ValidateFunc: validation.StringInSlice([]string{"EQ", "NE", "ANY"}, false),
							Description:  "EQ or NE or ANY - the comparison mode is 'value', recorded by the specified 'key'",
						},
						"key": {
							Type:        schema.TypeString,
							Required:    true,
							Description: "key that are taken into account when analyzing this rule will be identified",
						},
						"value": {
							Type:        schema.TypeString,
							Optional:    true,
							Description: "value that must match the key to be taken into account when analyzing this rule",
						},
					},
				},
			},
			"delete_async_mode": {
				Type:        schema.TypeBool,
				Computed:    true,
				Description: "async mode",
			},
			"anti_affinity_rules": {
				Type:     schema.TypeList,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"topology": {
							Type:         schema.TypeString,
							Required:     true,
							ValidateFunc: validation.StringInSlice([]string{"node", "compute"}, false),
							Description:  "compute or node, for whom rule applies",
						},
						"policy": {
							Type:         schema.TypeString,
							Required:     true,
							ValidateFunc: validation.StringInSlice([]string{"RECOMMENDED", "REQUIRED"}, false),
							Description:  "RECOMMENDED or REQUIRED, the degree of 'strictness' of this rule",
						},
						"mode": {
							Type:         schema.TypeString,
							Required:     true,
							ValidateFunc: validation.StringInSlice([]string{"EQ", "NE", "ANY"}, false),
							Description:  "EQ or NE or ANY - the comparison mode is 'value', recorded by the specified 'key'",
						},
						"key": {
							Type:        schema.TypeString,
							Required:    true,
							Description: "key that are taken into account when analyzing this rule will be identified",
						},
						"value": {
							Type:        schema.TypeString,
							Optional:    true,
							Description: "value that must match the key to be taken into account when analyzing this rule",
						},
					},
				},
			},
			"disks": {
				Type:     schema.TypeList,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"disk_name": {
							Type:        schema.TypeString,
							Required:    true,
							Description: "Name for disk",
						},
						"size": {
							Type:        schema.TypeInt,
							Required:    true,
							Description: "Disk size in GiB",
						},
						"sep_id": {
							Type:        schema.TypeInt,
							Computed:    true,
							Optional:    true,
							Description: "Storage endpoint provider ID; by default the same with boot disk",
						},
						"disk_type": {
							Type:         schema.TypeString,
							Computed:     true,
							Optional:     true,
							ValidateFunc: validation.StringInSlice([]string{"B", "D"}, false),
							Description:  "The type of disk in terms of its role in compute: 'B=Boot, D=Data'",
						},
						"pool": {
							Type:        schema.TypeString,
							Computed:    true,
							Optional:    true,
							Description: "Pool name; by default will be chosen automatically",
						},
						"node_ids": {
							Type:     schema.TypeSet,
							Optional: true,
							Elem: &schema.Schema{
								Type: schema.TypeInt,
							},
						},
						"desc": {
							Type:        schema.TypeString,
							Computed:    true,
							Optional:    true,
							Description: "Optional description",
						},
						"image_id": {
							Type:        schema.TypeInt,
							Computed:    true,
							Optional:    true,
							Description: "Specify image id for create disk from template",
						},
						"permanently": {
							Type:        schema.TypeBool,
							Optional:    true,
							Description: "Disk deletion status",
						},
						"disk_id": {
							Type:        schema.TypeInt,
							Computed:    true,
							Description: "Disk ID",
						},
						"present_to": {
							Type:     schema.TypeMap,
							Computed: true,
							Elem: &schema.Schema{
								Type: schema.TypeInt,
							},
						},
						"shareable": {
							Type:     schema.TypeBool,
							Computed: true,
						},
						"size_max": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"size_used": {
							Type:     schema.TypeInt,
							Computed: true,
						},
					},
				},
			},
			"extra_disks": {
				Type:     schema.TypeSet,
				Optional: true,
				MaxItems: constants.MAX_EXTRA_DISKS_PER_COMPUTE,
				Elem: &schema.Schema{
					Type: schema.TypeInt,
				},
				Description: "Optional list of IDs of extra disks to attach to this compute. You may specify several extra disks.",
			},
			"tags": {
				Type:     schema.TypeSet,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"key": {
							Type:     schema.TypeString,
							Required: true,
						},
						"value": {
							Type:     schema.TypeString,
							Required: true,
						},
					},
				},
			},
			"port_forwarding": {
				Type:     schema.TypeSet,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"public_port_start": {
							Type:     schema.TypeInt,
							Required: true,
						},
						"public_port_end": {
							Type:     schema.TypeInt,
							Optional: true,
							Default:  -1,
						},
						"local_port": {
							Type:     schema.TypeInt,
							Optional: true,
						},
						"proto": {
							Type:         schema.TypeString,
							Required:     true,
							ValidateFunc: validation.StringInSlice([]string{"tcp", "udp"}, false),
						},
						"rule_id": {
							Type:     schema.TypeInt,
							Computed: true,
						},
					},
				},
			},
			"user_access": {
				Type:     schema.TypeSet,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"username": {
							Type:     schema.TypeString,
							Required: true,
						},
						"access_type": {
							Type:     schema.TypeString,
							Required: true,
						},
					},
				},
			},
			"snapshot": {
				Type:     schema.TypeSet,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"label": {
							Type:     schema.TypeString,
							Required: true,
						},
					},
				},
			},
			"rollback": {
				Type:     schema.TypeSet,
				MaxItems: 1,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"label": {
							Type:     schema.TypeString,
							Required: true,
						},
					},
				},
			},
			"cd": {
				Type:     schema.TypeSet,
				Optional: true,
				MaxItems: 1,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"cdrom_id": {
							Type:     schema.TypeInt,
							Required: true,
						},
					},
				},
			},
			"pin_to_stack": {
				Type:     schema.TypeBool,
				Optional: true,
				Default:  false,
			},
			"auto_start_w_node": {
				Type:     schema.TypeBool,
				Optional: true,
				Computed: true,
			},
			"force_pin": {
				Type:     schema.TypeBool,
				Optional: true,
				Default:  false,
			},
			"enabled": {
				Type:        schema.TypeBool,
				Optional:    true,
				Computed:    true,
				Description: "If true - enable compute, else - disable",
			},
			"pause": {
				Type:     schema.TypeBool,
				Optional: true,
				Default:  false,
			},
			"reset": {
				Type:     schema.TypeBool,
				Optional: true,
				Default:  false,
			},
			"restore": {
				Type:     schema.TypeBool,
				Optional: true,
				Default:  false,
			},
			"force_stop": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     false,
				Description: "Flag for redeploy compute",
			},
			"force_resize": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     false,
				Description: "Flag for resize compute",
			},
			"detach_disks": {
				Type:     schema.TypeBool,
				Optional: true,
				Default:  true,
			},
			"permanently": {
				Type:     schema.TypeBool,
				Optional: true,
				Default:  true,
			},
			"numa_affinity": {
				Type:         schema.TypeString,
				Optional:     true,
				Default:      "none",
				ValidateFunc: validation.StringInSlice([]string{"none", "strict", "loose"}, false), // observe case while validating
				Description:  "Rule for VM placement with NUMA affinity.",
			},
			"cpu_pin": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     false,
				Description: "Run VM on dedicated CPUs. To use this feature, the system must be pre-configured by allocating CPUs on the physical node.",
			},
			"hp_backed": {
				Type:        schema.TypeBool,
				Optional:    true,
				Default:     false,
				Description: "Use Huge Pages to allocate RAM of the virtual machine. The system must be pre-configured by allocating Huge Pages on the physical node.",
			},
			"preferred_cpu": {
				Type:     schema.TypeList,
				Optional: true,
				Computed: true,
				Elem: &schema.Schema{
					Type: schema.TypeInt,
				},
				Description: "Recommended isolated CPUs. Field is ignored if compute.cpupin=False or compute.pinned=False",
			},
			"pci_devices": {
				Type:     schema.TypeSet,
				Optional: true,
				Computed: true,
				Elem: &schema.Schema{
					Type: schema.TypeInt,
				},
				Description: "ID of the connected pci devices",
			},
			// Computed properties
			"account_id": {
				Type:        schema.TypeInt,
				Computed:    true,
				Description: "ID of the account this compute instance belongs to.",
			},
			"account_name": {
				Type:        schema.TypeString,
				Computed:    true,
				Description: "Name of the account this compute instance belongs to.",
			},
			"acl": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"explicit": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"guid": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"right": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"status": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"type": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"user_group_id": {
							Type:     schema.TypeString,
							Computed: true,
						},
					},
				},
			},
			"affinity_weight": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"arch": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"boot_order": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Schema{
					Type: schema.TypeString,
				},
			},
			"boot_disk_id": {
				Type:        schema.TypeInt,
				Computed:    true,
				Description: "This compute instance boot disk ID.",
			},
			"cd_image_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"clone_reference": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"clones": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Schema{
					Type: schema.TypeInt,
				},
			},
			"computeci_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"created_by": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"created_time": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"deleted_by": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"deleted_time": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"devices": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"gid": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"guid": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"compute_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"interfaces": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"bus_number": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"conn_id": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"conn_type": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"def_gw": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"enabled": {
							Type:     schema.TypeBool,
							Computed: true,
						},
						"flip_group_id": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"guid": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"ip_address": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"listen_ssh": {
							Type:     schema.TypeBool,
							Computed: true,
						},
						"mac": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"mtu": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"name": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"net_id": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"netmask": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"net_type": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"node_id": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"pci_slot": {
							Type:     schema.TypeInt,
							Computed: true,
						},
						"qos": {
							Type:     schema.TypeList,
							Computed: true,
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"e_rate": {
										Type:     schema.TypeInt,
										Computed: true,
									},
									"guid": {
										Type:     schema.TypeString,
										Computed: true,
									},
									"in_brust": {
										Type:     schema.TypeInt,
										Computed: true,
									},
									"in_rate": {
										Type:     schema.TypeInt,
										Computed: true,
									},
								},
							},
						},
						"libvirt_settings": {
							Type:     schema.TypeList,
							Computed: true,
							Elem: &schema.Resource{
								Schema: map[string]*schema.Schema{
									"guid": {
										Type:     schema.TypeString,
										Computed: true,
									},
									"txmode": {
										Type:     schema.TypeString,
										Computed: true,
									},
									"ioeventfd": {
										Type:     schema.TypeString,
										Computed: true,
									},
									"event_idx": {
										Type:     schema.TypeString,
										Computed: true,
									},
									"queues": {
										Type:     schema.TypeInt,
										Computed: true,
									},
									"rx_queue_size": {
										Type:     schema.TypeInt,
										Computed: true,
									},
									"tx_queue_size": {
										Type:     schema.TypeInt,
										Computed: true,
									},
								},
							},
						},
						"target": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"type": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"vnfs": {
							Type:     schema.TypeList,
							Computed: true,
							Elem: &schema.Schema{
								Type: schema.TypeInt,
							},
						},
					},
				},
			},
			"image_name": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"lock_status": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"manager_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"manager_type": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"migrationjob": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"milestones": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"natable_vins_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"natable_vins_ip": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"natable_vins_name": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"natable_vins_network": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"natable_vins_network_name": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"need_reboot": {
				Type:     schema.TypeBool,
				Computed: true,
			},
			"numa_node_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"os_users": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"guid": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "GUID of this guest OS user.",
						},

						"login": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "Login name of this guest OS user.",
						},

						"password": {
							Type:     schema.TypeString,
							Computed: true,
							//Sensitive:   true,
							Description: "Password of this guest OS user.",
						},

						"public_key": {
							Type:        schema.TypeString,
							Computed:    true,
							Description: "SSH public key of this guest OS user.",
						},
					},
				},
				Description: "Guest OS users provisioned on this compute instance.",
			},
			"pinned": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"reference_id": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"registered": {
				Type:     schema.TypeBool,
				Computed: true,
			},
			"res_name": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"reserved_node_cpus": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Schema{
					Type: schema.TypeInt,
				},
			},
			"rg_name": {
				Type:        schema.TypeString,
				Computed:    true,
				Description: "Name of the resource group where this compute instance is located.",
			},
			"snap_sets": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"disks": {
							Type:     schema.TypeList,
							Computed: true,
							Elem: &schema.Schema{
								Type: schema.TypeInt,
							},
						},
						"guid": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"label": {
							Type:     schema.TypeString,
							Computed: true,
						},
						"timestamp": {
							Type:     schema.TypeInt,
							Computed: true,
						},
					},
				},
			},
			"stack_name": {
				Type:        schema.TypeString,
				Computed:    true,
				Description: "Name of the stack, on which VM started",
			},
			"stateless_sep_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"stateless_sep_type": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"status": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"tech_status": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"updated_by": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"updated_time": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"user_managed": {
				Type:     schema.TypeBool,
				Computed: true,
			},
			"vnc_password": {
				Type:     schema.TypeString,
				Computed: true,
			},
			"vgpus": {
				Type:     schema.TypeList,
				Computed: true,
				Elem: &schema.Schema{
					Type: schema.TypeInt,
				},
			},
			"virtual_image_id": {
				Type:     schema.TypeInt,
				Computed: true,
			},
			"virtual_image_name": {
				Type:     schema.TypeString,
				Computed: true,
			},
		},
	}
}
