package one

import (
	"strconv"

	"gitlab.ippon.fr/ims/opennebula-api/network"

	"github.com/hashicorp/terraform/helper/schema"
)

func resourceVNetwork() *schema.Resource {
	return &schema.Resource{
		Create: resourceVNetworkCreate,
		Read:   resourceVNetworkRead,
		Update: resourceVNetworkUpdate,
		Delete: resourceVNetworkDelete,

		Schema: map[string]*schema.Schema{
			"name": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"cluster_id": &schema.Schema{
				Type:     schema.TypeInt,
				Optional: true,
				Default:  -1,
			},
			"vn_mad": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"bridge": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"vlan_id": &schema.Schema{
				Type:     schema.TypeInt,
				Optional: true,
			},
			"automatic_vlan_id": &schema.Schema{
				Type:          schema.TypeBool,
				Optional:      true,
				ConflictsWith: []string{"vlan_id"},
			},
			"phydev": &schema.Schema{
				Type:     schema.TypeString,
				Optional: true,
			},
			"network_address": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"network_mask": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"gateway": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"dns": &schema.Schema{
				Type:     schema.TypeString,
				Required: true,
			},
			"address_range": &schema.Schema{
				Type:     schema.TypeList,
				Optional: true,
				Elem: &schema.Resource{
					Schema: map[string]*schema.Schema{
						"type": &schema.Schema{
							Type:     schema.TypeString,
							Optional: true,
							Default:  "IP4",
						},
						"ip": &schema.Schema{
							Type:     schema.TypeString,
							Required: true,
						},
						"mac": &schema.Schema{
							Type:     schema.TypeString,
							Optional: true,
						},
						"size": &schema.Schema{
							Type:     schema.TypeInt,
							Required: true,
						},
					},
				},
			},
		},
	}
}

func resourceVNetworkCreate(d *schema.ResourceData, m interface{}) error {
	session := m.(*Client).NetworkSession

	var vnet *network.VNetwork
	var err error
	vnet, err = session.CheckNetworkExistence(d.Get("name").(string), d.Get("network_address").(string))

	if err != nil {
		return err
	}

	if vnet != nil {
		d.SetId(strconv.Itoa(vnet.ID))
		return nil
	}

	net := network.VNetwork{
		Name: d.Get("name").(string),
	}

	net.VNMad = d.Get("vn_mad").(string)
	net.Bridge = d.Get("bridge").(string)
	net.NetworkAddress = d.Get("network_address").(string)
	net.Gateway = d.Get("gateway").(string)

	if v, ok := d.GetOk("automatic_vlan_id"); ok && v.(bool) {
		net.AutomaticVlanID = "YES"
	} else {
		net.VlanID = d.Get("vlan_id").(int)
	}

	err = session.AllocateVN(&net, d.Get("cluster_id").(int))
	if err != nil {
		return err
	}

	addressRanges := d.Get("address_range").([]interface{})
	for _, ar := range addressRanges {
		var arMap = ar.(map[string]interface{})

		var ip, mac string
		var size int

		if v, ok := arMap["ip"]; ok {
			ip = v.(string)
		}
		if v, ok := arMap["mac"]; ok {
			mac = v.(string)
		}
		if v, ok := arMap["size"]; ok {
			size = v.(int)
		}

		arObj := network.CreateAR4(ip, mac, size)

		err = session.AddAR(&net, arObj)

		if err != nil {
			return err
		}
	}

	d.SetId(strconv.Itoa(net.ID))

	return nil
}

func resourceVNetworkRead(d *schema.ResourceData, m interface{}) error {
	session := m.(*Client).NetworkSession
	var vnet *network.VNetwork
	var err error
	vnet, err = session.CheckNetworkExistence(d.Get("name").(string), d.Get("network_address").(string))

	if err != nil {
		return err
	}

	if vnet != nil {
		d.SetId(strconv.Itoa(vnet.ID))
	}
	return nil
}

func resourceVNetworkUpdate(d *schema.ResourceData, m interface{}) error {
	return nil
}

func resourceVNetworkDelete(d *schema.ResourceData, m interface{}) error {
	session := m.(*Client).NetworkSession
	objID, err := strconv.Atoi(d.Id())
	if err != nil {
		return err
	}

	err = session.DeleteVN(objID)
	if err != nil {
		return err
	}
	return nil
}