package netboxgo

import (
	"context"
	"fmt"
	"net/http"
	"net/url"
	"time"

	"github.com/gorilla/schema"
)

type VirtualizationInterfacesService service

// NewVirtualizationInterface is used for creating a new virtualization interface
type NewVirtualizationInterface struct {
	CustomFields *interface{} `json:"custom_fields,omitempty"`
	Name         string       `json:"name"`
	Mode         string       `json:"mode,omitempty"`
	Description  string       `json:"description,omitempty"`
	MACAddress   string       `json:"mac_address,omitempty"`
	Tags         *[]struct {
		Name  string `json:"name"`
		Slug  string `json:"slug"`
		Color string `json:"color"`
	} `json:"tags,omitempty"`
	TaggedVLANs    *[]int `json:"tagged_vlans,omitempty"`
	Bridge         int    `json:"bridge,omitempty"`
	Parent         int    `json:"parent,omitempty"`
	UntaggedVLAN   int    `json:"untagged_vlan,omitempty"`
	MTU            int    `json:"mtu,omitempty"`
	VirtualMachine int    `json:"virtual_machine"`
	Enabled        bool   `json:"enabled,omitempty"`
}

// VirtualizationInterfaces is a list of interfaces
type VirtualizationInterfaces struct {
	Next     string                    `json:"next,omitempty"`
	Previous string                    `json:"previous,omitempty"`
	Results  []VirtualizationInterface `json:"results,omitempty"`
	Count    int                       `json:"count,omitempty"`
}

// VirtualizationInterface is one virtualization interface
type VirtualizationInterface struct {
	LastUpdated  time.Time   `json:"last_updated"`
	CustomFields interface{} `json:"custom_fields"`
	Mode         struct {
		Label string `json:"label"`
		Value string `json:"value"`
	} `json:"mode"`
	Display        string `json:"display"`
	Description    string `json:"description"`
	Created        string `json:"created"`
	URL            string `json:"url"`
	Name           string `json:"name"`
	MACAddress     string `json:"mac_address"`
	VirtualMachine struct {
		URL     string `json:"url"`
		Display string `json:"display"`
		Name    string `json:"name"`
		ID      int    `json:"id"`
	} `json:"virtual_machine"`
	TaggedVLANs []struct {
		URL     string `json:"url"`
		Display string `json:"display"`
		Name    string `json:"name"`
		ID      int    `json:"id"`
		Vid     int    `json:"vid"`
	} `json:"tagged_vlans"`
	Tags []struct {
		URL     string `json:"url"`
		Display string `json:"display"`
		Name    string `json:"name"`
		Slug    string `json:"slug"`
		Color   string `json:"color"`
		ID      int    `json:"id"`
	} `json:"tags"`
	Bridge struct {
		URL            string `json:"url"`
		Display        string `json:"display"`
		Name           string `json:"name"`
		VirtualMachine struct {
			URL     string `json:"url"`
			Display string `json:"display"`
			Name    string `json:"name"`
			ID      int    `json:"id"`
		} `json:"virtual_machine"`
		ID int `json:"id"`
	} `json:"bridge"`
	Parent struct {
		URL            string `json:"url"`
		Display        string `json:"display"`
		Name           string `json:"name"`
		VirtualMachine struct {
			URL     string `json:"url"`
			Display string `json:"display"`
			Name    string `json:"name"`
			ID      int    `json:"id"`
		} `json:"virtual_machine"`
		ID int `json:"id"`
	} `json:"parent"`
	UntaggedVLAN struct {
		URL     string `json:"url"`
		Display string `json:"display"`
		Name    string `json:"name"`
		ID      int    `json:"id"`
		Vid     int    `json:"vid"`
	} `json:"untagged_vlan"`
	ID               int  `json:"id"`
	MTU              int  `json:"mtu"`
	CountIPAddresses int  `json:"count_ipaddresses"`
	CountFHRPGroups  int  `json:"count_fhrp_groups"`
	Enabled          bool `json:"enabled"`
}

// VirtualizationInterfaceFilter is used to filter out virtualization interfaces
type VirtualizationInterfaceFilter struct {
	// User specific filters
	ID               string `schema:"id,omitempty"`
	Name             string `schema:"name,omitempty"`
	ConnectionStatus string `schema:"connection_status,omitempty"`
	Type             string `schema:"type,omitempty"`
	MTU              string `schema:"mtu,omitempty"`
	MGMTOnly         string `schema:"mgmt_only,omitempty"`
	Mode             string `schema:"mode,omitempty"`
	Description      string `schema:"description,omitempty"`
	Q                string `schema:"q,omitempty"`
	VirtualMachine   string `schema:"device,omitempty"`
	ClusterID        string `schema:"cluster_id,omitempty"`
	VirtualMachineID string `schema:"virtual_machine_id,omitempty"`
	Cabled           string `schema:"cabled,omitempty"`
	Kind             string `schema:"kind,omitempty"`
	LagID            string `schema:"lag_id,omitempty"`
	MACAddress       string `schema:"mac_address,omitempty"`
	Tag              string `schema:"tag,omitempty"`
	VLANID           string `schema:"vlan_id,omitempty"`
	VLAN             string `schema:"vlan,omitempty"`
	ParentID         string `schema:"parent_id,omitempty"`
	BridgeID         string `schema:"bridge_id,omitempty"`

	Offset int64 `schema:"offset,omitempty"`
	Limit  int64 `schema:"limit,omitempty"`
}

const virtualizationInterfacesPath = virtualizationPath + "/interfaces"

// List devices. DeviceFilter is used to list based on filter queries.
func (s *VirtualizationInterfacesService) List(ctx context.Context, f *VirtualizationInterfaceFilter) (*VirtualizationInterfaces, error) {
	var interfaces VirtualizationInterfaces
	var query string
	var req *http.Request
	var err error

	encoder := schema.NewEncoder()

	form := url.Values{}
	err = encoder.Encode(f, form)
	if err != nil {
		return &interfaces, err
	}
	query = form.Encode()

	req, err = s.client.newRequest(ctx, "GET", virtualizationInterfacesPath, query, nil)
	if err != nil {
		return &interfaces, err
	}

	_, err = s.client.do(req, &interfaces)
	if err != nil {
		return &interfaces, err
	}

	return &interfaces, nil
}

// Create a interfaces
func (s *VirtualizationInterfacesService) Create(ctx context.Context, c *NewVirtualizationInterface) (*VirtualizationInterface, error) {
	var err error
	var req *http.Request
	var nic VirtualizationInterface

	req, err = s.client.newRequest(ctx, "POST", virtualizationInterfacesPath, "", c)
	if err != nil {
		return &nic, fmt.Errorf("unable to create request: %w", err)
	}

	_, err = s.client.do(req, &nic)
	if err != nil {
		return &nic, fmt.Errorf("unable to do request: %w", err)
	}

	return &nic, nil
}

// Delete a interface
func (s *VirtualizationInterfacesService) Delete(ctx context.Context, i string) error {
	var err error
	var req *http.Request

	req, err = s.client.newRequest(ctx, "DELETE", virtualizationInterfacesPath+"/"+i+"/", "", nil)
	if err != nil {
		return fmt.Errorf("unable to create request: %w", err)
	}

	_, err = s.client.do(req, nil)
	if err != nil {
		return fmt.Errorf("unable to do request: %w", err)
	}

	return nil
}