package driver

import (
	"fmt"
	"io"
	"io/ioutil"
	"math"
	"os"
	"os/exec"
	"strconv"
	"strings"

	nclinkmodel "gitee.com/cmtba/nclink/models"
)

type getFunc func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool)
type setFunc func(item nclinkmodel.SetItem, virtualDevice *virtualMachine) (*nclinkmodel.SetItem, bool)
type sampleFunc func(n uint64, virtualDevice *virtualMachine) (interface{}, bool)
type driverItem struct {
	PrivilegeLevel int
	Get            getFunc
	Set            setFunc
	Sample         sampleFunc
}

type fileAttrib struct {
	Type       string `json:"type"`
	Size       int64  `json:"size"`
	ChangeTime string `json:"changeTime"`
}
type toolParam struct {
	Length         *float32 `json:"length,omitempty"`
	Radius         *float32 `json:"radius"`
	LengthAbrasion *float32 `json:"length_abrasion,omitempty"`
	RadiusAbrasion *float32 `json:"radius_abrasion,omitempty"`
}
type crd struct {
	X *float32 `json:"x,omitempty"`
	Y *float32 `json:"y,omitempty"`
	Z *float32 `json:"z,omitempty"`
	C *float32 `json:"c,omitempty"`
}
type axis struct {
	Name        string
	Number      int
	Type        string
	ActSpeed    float32
	CmdSpeed    float32
	ActPosition float32
	CmdPosition float32
	Current     float32
}

const (
	actpos   = 0
	cmdpos   = 1
	actspeed = 2
	cmdspeed = 3
	current  = 4
)

type runState struct {
	line       uint64
	state      int64
	progNumber int64
	toolNumber int64
}

var statusS = []string{"free", "running", "holding"}
var statusN = []int{0, 1, 2}
var drivers map[string]*driverItem

func init() {
	drivers = make(map[string]*driverItem)

	dataPool := new([100][1000]float32) //预先生成100组，每组10000个点的数据，采样数据直接从这里面取
	for i := 0; i < 100; i++ {
		for j := 0; j < 1000; j++ {
			dataPool[i][j] = float32(int32(float64(i+1)*100000.0*math.Sin(3.14*2.0*float64(j)/200.0))) / 10000.0
		}
	}

	drivers["NC_LINK_ROOT:MACHINE:STATUS"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				var status string
				switch virtualDevice.RunState.state {
				case 0:
					status = "running"
				case 1:
					status = "free"
				case 2:
					status = "holding"
				default:
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Values = append(response.Values, status)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			var status int
			if len(virtualDevice.ProgList) == 0 {
				status = 1
			} else {
				status = statusN[int(virtualDevice.SampleHeartBeat/300000)%len(statusS)]
			}
			for i := uint64(0); i < n; i++ {
				virtualDevice.SampleBuffer.Status[i] = status
			}
			virtualDevice.RunState.state = int64(status)
			return virtualDevice.SampleBuffer.Status[0:n], true
		},
	}

	drivers["NC_LINK_ROOT:MACHINE:FEED_SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				var v uint32
				switch virtualDevice.RunState.state {
				case 0:
					v = 3000
				case 1, 2:
					v = 0
				default:
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Values = append(response.Values, v)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]uint32, n)
			var status int
			if len(virtualDevice.ProgList) == 0 {
				status = 1
			} else {
				status = statusN[int(virtualDevice.SampleHeartBeat/300000)%len(statusS)]
			}
			var v uint32
			switch status {
			case 0:
				v = 3000
			default:
				v = 0
			}
			for i := uint64(0); i < n; i++ {
				data[i] = v
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:FEED_OVERRIDE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				response.Values = append(response.Values, 100)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]uint32, n)
			for i := uint64(0); i < n; i++ {
				data[i] = 100
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:SPDL_OVERRIDE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				response.Values = append(response.Values, 100)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]uint32, n)
			for i := uint64(0); i < n; i++ {
				data[i] = 100
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:PART_COUNT"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				response.Values = append(response.Values, virtualDevice.SampleHeartBeat/300000)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]uint32, n)
			for i := uint64(0); i < n; i++ {
				data[i] = uint32((virtualDevice.SampleHeartBeat + i) / 300000)
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:WARNING"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				response.Values = append(response.Values, []int{})
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([][]uint32, n)
			for i := uint64(0); i < n; i++ {
				data[i] = []uint32{}
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:WARNING"] = drivers["NC_LINK_ROOT:MACHINE:WARNING"]

	funcGetAxisValue := func(axis int, dataindex int, item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
		response := &item
		if virtualDevice == nil {
			response.Code = nclinkmodel.NG
			return response, false
		}
		var operation string
		if item.Params != nil && item.Params.Operation != "" {
			operation = item.Params.Operation
		} else {
			operation = nclinkmodel.OP_get_value
		}
		var targetdata *float32
		switch dataindex {
		case actpos:
			targetdata = &virtualDevice.Axes[axis].ActPosition
		case cmdpos:
			targetdata = &virtualDevice.Axes[axis].CmdPosition
		case actspeed:
			targetdata = &virtualDevice.Axes[axis].ActSpeed
		case cmdspeed:
			targetdata = &virtualDevice.Axes[axis].CmdSpeed
		case current:
			targetdata = &virtualDevice.Axes[axis].Current
		}
		switch operation {
		case nclinkmodel.OP_get_value:
			*targetdata = dataPool[axis*5+dataindex][virtualDevice.SampleHeartBeat%1000]
			response.Values = append(response.Values, *targetdata)
			response.Code = nclinkmodel.OK
			return response, true
		default:
			response.Code = nclinkmodel.NG
			return response, false
		}
	}
	funcGetAxisName := func(axis int, item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
		response := &item
		if virtualDevice == nil {
			response.Code = nclinkmodel.NG
			return response, false
		}
		var operation string
		if item.Params != nil && item.Params.Operation != "" {
			operation = item.Params.Operation
		} else {
			operation = nclinkmodel.OP_get_value
		}
		switch operation {
		case nclinkmodel.OP_get_value:
			response.Values = append(response.Values, virtualDevice.Axes[axis].Name)
			response.Code = nclinkmodel.OK
			return response, true
		default:
			response.Code = nclinkmodel.NG
			return response, false
		}
	}
	funcGetAxisType := func(axis int, item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
		response := &item
		if virtualDevice == nil {
			response.Code = nclinkmodel.NG
			return response, false
		}
		var operation string
		if item.Params != nil && item.Params.Operation != "" {
			operation = item.Params.Operation
		} else {
			operation = nclinkmodel.OP_get_value
		}
		switch operation {
		case nclinkmodel.OP_get_value:

			response.Values = append(response.Values, virtualDevice.Axes[axis].Type)
			response.Code = nclinkmodel.OK
			return response, true

		default:
			response.Code = nclinkmodel.NG
			return response, false
		}
	}
	funcGetAxisNumber := func(axis int, item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
		response := &item
		if virtualDevice == nil {
			response.Code = nclinkmodel.NG
			return response, false
		}
		var operation string
		if item.Params != nil && item.Params.Operation != "" {
			operation = item.Params.Operation
		} else {
			operation = nclinkmodel.OP_get_value
		}
		switch operation {
		case nclinkmodel.OP_get_value:
			response.Values = append(response.Values, virtualDevice.Axes[axis].Number)
			response.Code = nclinkmodel.OK
			return response, true
		default:
			response.Code = nclinkmodel.NG
			return response, false
		}
	}
	funcAxisSample := func(axis int, dataindex int, n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
		var status int
		if len(virtualDevice.ProgList) == 0 {
			status = 1
		} else {
			status = statusN[int(virtualDevice.SampleHeartBeat/300000)%len(statusS)]
		}
		var targetdata *float32
		switch dataindex {
		case actpos:
			targetdata = &virtualDevice.Axes[axis].ActPosition
		case cmdpos:
			targetdata = &virtualDevice.Axes[axis].CmdPosition
		case actspeed:
			targetdata = &virtualDevice.Axes[axis].ActSpeed
		case cmdspeed:
			targetdata = &virtualDevice.Axes[axis].CmdSpeed
		case current:
			targetdata = &virtualDevice.Axes[axis].Current
		}
		switch status {
		case 0:
			s := virtualDevice.SampleHeartBeat % 1000
			for i := s; i < s+n; i++ {
				virtualDevice.SampleBuffer.Axis[axis][dataindex][i-s] = dataPool[axis*5+dataindex][i%1000]
			}
			*targetdata = dataPool[axis*5+dataindex][(s+n-1)%1000]
		case 1, 2:
			v := *targetdata
			for i := uint64(0); i < n; i++ {
				virtualDevice.SampleBuffer.Axis[axis][dataindex][i] = float32(v)
			}
		default:
		}
		return virtualDevice.SampleBuffer.Axis[axis][dataindex][0:n], true
	}

	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:NAME"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisName(0, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:TYPE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisType(0, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:NUMBER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisNumber(0, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:SCREW:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(0, actpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(0, actpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:SCREW:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(0, actspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(0, actspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:SERVO_DRIVER:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(0, cmdpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(0, cmdpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:SERVO_DRIVER:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(0, cmdspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(0, cmdspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#0:MOTOR:CURRENT"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(0, current, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(0, current, n, virtualDevice)
		},
	}

	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:NAME"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisName(1, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:TYPE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisType(1, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:NUMBER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisNumber(1, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:SCREW:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(1, actpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(1, actpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:SCREW:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(1, actspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(1, actspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:SERVO_DRIVER:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(1, cmdpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(1, cmdpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:SERVO_DRIVER:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(1, cmdspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(1, cmdspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#1:MOTOR:CURRENT"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(1, current, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(1, current, n, virtualDevice)
		},
	}

	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:NAME"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisName(2, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:TYPE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisType(2, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:NUMBER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisNumber(2, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:SCREW:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(2, actpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(2, actpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:SCREW:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(2, actspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(2, actspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:SERVO_DRIVER:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(2, cmdpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(2, cmdpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:SERVO_DRIVER:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(2, cmdspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(2, cmdspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#2:MOTOR:CURRENT"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(2, current, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(2, current, n, virtualDevice)
		},
	}

	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:NAME"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisName(5, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:TYPE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisType(5, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:NUMBER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisNumber(5, item, virtualDevice)
		},
		Set:    nil,
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:MOTOR:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(5, actspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(5, actspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:MOTOR:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(5, actpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(5, actpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:SERVO_DRIVER:POSITION"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(5, cmdpos, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(5, cmdpos, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:SERVO_DRIVER:SPEED"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(5, cmdspeed, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(5, cmdspeed, n, virtualDevice)
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:AXIS#5:MOTOR:CURRENT"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			return funcGetAxisValue(5, current, item, virtualDevice)
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			return funcAxisSample(5, current, n, virtualDevice)
		},
	}

	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:LINE_NUMBER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:

				response.Values = append(response.Values, virtualDevice.RunState.line)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]uint32, n)
			var status int
			if len(virtualDevice.ProgList) == 0 {
				status = 1
			} else {
				status = statusN[int(virtualDevice.SampleHeartBeat/300000)%len(statusS)]
			}
			var v uint64
			switch status {
			case 0:
				progNumber := (virtualDevice.SampleHeartBeat / 300000) % uint64(len(virtualDevice.ProgList))
				if virtualDevice.ProgList[progNumber].lineNumber == 0 {
					v = 0
				} else {
					v = (virtualDevice.SampleHeartBeat / 300) % uint64(virtualDevice.ProgList[progNumber].lineNumber)
				}
				virtualDevice.RunState.line = v
			case 1:
				v = virtualDevice.RunState.line
			default:
				v = 0
			}
			for i := uint64(0); i < n; i++ {
				data[i] = uint32(v)
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:PROGRAM_NUMBER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				response.Values = append(response.Values, virtualDevice.RunState.progNumber)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]uint32, n)
			var status int
			if len(virtualDevice.ProgList) == 0 {
				status = 1
			} else {
				status = statusN[int(virtualDevice.SampleHeartBeat/300000)%len(statusS)]
			}
			var v uint64
			switch status {
			case 0:
				v = (virtualDevice.SampleHeartBeat / 300000) % uint64(len(virtualDevice.ProgList))
				virtualDevice.RunState.progNumber = int64(v)
			default:
				v = uint64(virtualDevice.RunState.progNumber)
			}
			for i := uint64(0); i < n; i++ {
				data[i] = uint32(v)
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:TOOL_NUMBER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:

				response.Values = append(response.Values, virtualDevice.RunState.toolNumber)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]uint32, n)
			var status int
			if len(virtualDevice.ProgList) == 0 {
				status = 1
			} else {
				status = statusN[int(virtualDevice.SampleHeartBeat/300000)%len(statusS)]
			}
			var v uint64
			switch status {
			case 0:
				v = virtualDevice.SampleHeartBeat / 30000
				virtualDevice.RunState.toolNumber = int64(v)
			default:
				v = uint64(virtualDevice.RunState.toolNumber)
			}
			for i := uint64(0); i < n; i++ {
				data[i] = uint32(v)
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:TOOL_PARAM"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				if item.Params == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Params.Operation = item.Params.Operation
				indexes := item.Params.Indexes
				if len(indexes) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Params.Indexes = indexes
				for _, indexStr := range indexes {
					indexN := strings.Split(indexStr, "-")
					switch len(indexN) {
					case 1:
						index, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						if index < 0 || index >= len(virtualDevice.ToolParam) {
							response.Code = nclinkmodel.NG
							return response, false
						} else {
							response.Values = append(response.Values, virtualDevice.ToolParam[index])
						}
					case 2:
						index0, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						index1, err := strconv.Atoi(indexN[1])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						for index := index0; index <= index1; index++ {
							if index < 0 || index >= len(virtualDevice.ToolParam) {
								response.Code = nclinkmodel.NG
								return response, false
							} else {
								response.Values = append(response.Values, virtualDevice.ToolParam[index])
							}
						}
					default:
						response.Code = nclinkmodel.NG
						return response, false
					}
				}
				response.Code = nclinkmodel.OK
				return response, true

			case nclinkmodel.OP_get_length:
				response.Values = append(response.Values, len(virtualDevice.ToolParam))
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: func(item nclinkmodel.SetItem, virtualDevice *virtualMachine) (item2 *nclinkmodel.SetItem, b bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_set_value
			}
			switch operation {
			case nclinkmodel.OP_set_value:
				index := item.Params.Index
				if index == nil || *index < 0 || *index >= len(virtualDevice.ToolParam) {
					response.Code = nclinkmodel.NG
					return response, false
				}
				if item.Params.Value == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				value, ok := item.Params.Value.(map[string]interface{})
				if !ok {
					response.Code = nclinkmodel.NG
					return response, false
				}
				for k, v := range value {
					switch k {
					case "length":
						*virtualDevice.ToolParam[*index].Length = float32(v.(float64))
					case "radius":
						*virtualDevice.ToolParam[*index].Radius = float32(v.(float64))
					case "length_abrasion":
						*virtualDevice.ToolParam[*index].LengthAbrasion = float32(v.(float64))
					case "radius_abrasion":
						*virtualDevice.ToolParam[*index].RadiusAbrasion = float32(v.(float64))
					}
				}
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:PROGRAM"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				if int64(len(virtualDevice.ProgList)) <= virtualDevice.RunState.progNumber {
					response.Values = append(response.Values, "")
				} else {
					response.Values = append(response.Values, virtualDevice.ProgList[virtualDevice.RunState.progNumber].name)
				}
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: nil,
		Sample: func(n uint64, virtualDevice *virtualMachine) (interface{}, bool) {
			data := make([]string, n)
			var status int
			if len(virtualDevice.ProgList) == 0 {
				status = 1
			} else {
				status = statusN[int(virtualDevice.SampleHeartBeat/300000)%len(statusS)]
			}
			var v string
			if int64(len(virtualDevice.ProgList)) <= virtualDevice.RunState.progNumber {
				v = ""
			} else {
				v = virtualDevice.ProgList[virtualDevice.RunState.progNumber].name
			}
			switch status {
			case 0:
			default:
			}
			for i := uint64(0); i < n; i++ {
				data[i] = v
			}
			return data, true
		},
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:SUBPROGRAM"] = drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:PROGRAM"]
	drivers["NC_LINK_ROOT:MACHINE:FILE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				if item.Params == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				keys := item.Params.Keys
				if len(keys) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				offset := item.Params.Offset
				length := item.Params.Length
				if len(keys) == 0 || offset == nil || length == nil || *offset < 0 || *length <= 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				for _, key := range keys {
					file, err := os.Open(virtualDevice.ProgDir + key)
					if err != nil {
						response.Values = append(response.Values, nil)
						fmt.Printf("Failed to Open File \"%s\"\n", virtualDevice.ProgDir+key)
						continue
					}
					fileinfo, err := file.Stat()
					if err != nil || fileinfo.IsDir() || fileinfo.Size() < int64(*offset) {
						response.Values = append(response.Values, nil)
						file.Close()
						continue
					}
					_offet, err := file.Seek(int64(*offset), 0)
					if int64(*offset) != _offet || err != nil {
						response.Values = append(response.Values, nil)
						file.Close()
						continue
					}
					data := make([]byte, *length)
					n, err := file.Read(data)
					if err != nil || n <= 0 {
						response.Values = append(response.Values, nil)
						file.Close()
						continue
					}
					encodedData := make([]byte, n*2)
					for i := 0; i < n; i++ {
						c0 := (data[i] >> 4) & 0x0f
						c1 := data[i] & 0x0f
						if c0 > 9 {
							encodedData[2*i] = c0 - 10 + 'A'
						} else {
							encodedData[2*i] = c0 + '0'
						}
						if c1 > 9 {
							encodedData[2*i+1] = c1 - 10 + 'A'
						} else {
							encodedData[2*i+1] = c1 + '0'
						}
					}
					response.Values = append(response.Values, string(encodedData))
					file.Close()
				}
				response.Code = nclinkmodel.OK
				return response, true
			case nclinkmodel.OP_get_keys:
				prefixLen := len(virtualDevice.ProgDir)
				var IterateDir func(dir string) []interface{}
				IterateDir = func(dir string) []interface{} {
					files := make([]interface{}, 0)
					fileInfos, err := ioutil.ReadDir(dir)
					if err != nil {
						return files
					}
					for _, fileInfo := range fileInfos {
						files = append(files, (dir + fileInfo.Name())[prefixLen:])
						if fileInfo.IsDir() {
							files = append(files, IterateDir(dir+fileInfo.Name())...)
						}
					}
					return files
				}
				files := IterateDir(virtualDevice.ProgDir)
				response.Values = files
				response.Code = nclinkmodel.OK
				return response, true
			case nclinkmodel.OP_get_attributes:
				keys := item.Params.Keys
				if len(keys) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				attributes := make([]interface{}, 0)
				for _, key := range keys {
					fileInfo, err := os.Stat(virtualDevice.ProgDir + key)
					if err != nil {
						attributes = append(attributes, nil)
						continue
					}
					attr := fileAttrib{}
					if fileInfo.IsDir() {
						attr.Type = "directory"
					} else {
						attr.Type = "file"
					}
					attr.Size = fileInfo.Size()
					t := fileInfo.ModTime()
					attr.ChangeTime = fmt.Sprintf("%d/%02d/%02d %02d:%02d:%02d", t.Year(), t.Month(), t.Day(), t.Hour(), t.Minute(), t.Second())
					attributes = append(attributes, attr)
				}
				response.Code = nclinkmodel.OK
				response.Values = attributes
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: func(item nclinkmodel.SetItem, virtualDevice *virtualMachine) (*nclinkmodel.SetItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_set_value
			}
			switch operation {
			case nclinkmodel.OP_set_value:
				key := item.Params.Key
				offset := item.Params.Offset
				length := item.Params.Length
				if item.Params.Value == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				if len(key) == 0 || offset == nil || length == nil || *offset < 0 || *length <= 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				value, ok := item.Params.Value.(string)
				if !ok {
					response.Code = nclinkmodel.NG
					return response, false
				}

				if len(value) != 2*(*length) {
					response.Code = nclinkmodel.NG
					return response, false
				}
				byteValue := []byte(value)

				for i := 0; i < len(byteValue); i++ {
					if byteValue[i] < '0' || byteValue[i] > 'F' || (byteValue[i] > '9' && byteValue[i] < 'A') {
						response.Code = nclinkmodel.NG
						return response, false
					}
				}
				file, err := os.OpenFile(virtualDevice.ProgDir+key, os.O_CREATE|os.O_RDWR, 0666)
				if err != nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				fileinfo, err := file.Stat()
				if err != nil || fileinfo.IsDir() {
					file.Close()
					response.Code = nclinkmodel.NG
					return response, false
				}
				if fileinfo.Size() < int64(*offset) {
					_, err := file.Seek(0, io.SeekEnd)
					if err != nil {
						file.Close()
						response.Code = nclinkmodel.NG
						return response, false
					}
					zeros := make([]byte, 1024)
					for j := int64(0); j < (int64(*offset)-fileinfo.Size())/1024; j++ {
						n, err := file.Write(zeros)
						if n != len(zeros) || err != nil {
							file.Close()
							response.Code = nclinkmodel.NG
							return response, false
						}
					}
					n := (int64(*offset) - fileinfo.Size()) % 1024
					if n != 0 {
						k, err := file.Write(zeros[0:n])
						if int64(k) != n || err != nil {
							file.Close()
							response.Code = nclinkmodel.NG
							return response, false
						}
					}
				}

				_, err = file.Seek(int64(*offset), io.SeekStart)
				if err != nil {
					file.Close()
					response.Code = nclinkmodel.NG
					return response, false
				}

				bytes := make([]byte, 1024)
				var j, k int
				for j = 0; j < *length/1024+1; j++ {
					for k = 0; k < 1024 && k < *length-j*1024; k++ {
						c0 := byteValue[2*(k+1024*j)]
						c1 := byteValue[2*(k+1024*j)+1]
						if c0 > '9' {
							c0 -= 'A'
							c0 += 10
						}
						if c1 > '9' {
							c1 -= 'A'
							c1 += 10
						}
						bytes[k] = ((c0 << 4) & 0xf0) | (c1 & 0x0f)
					}
					if k > 0 {
						n, err := file.Write(bytes[0:k])
						if err != nil || n != k {
							fmt.Printf("Faild to Write File \"%s\":%v\n", virtualDevice.ProgDir+key, err)
						}
					}
				}
				file.Close()
				response.Code = nclinkmodel.OK
				return response, true
			case "add":
				response.Params.Key = item.Params.Key
				key := item.Params.Key
				err := os.Mkdir(virtualDevice.ProgDir+key, os.ModePerm)
				if err != nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Code = nclinkmodel.OK
				return response, true
			case "delete":
				key := item.Params.Key
				err := os.Remove(virtualDevice.ProgDir + key)
				if err != nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:FILE"] = drivers["NC_LINK_ROOT:MACHINE:FILE"]

	regDriver := func(reg int) *driverItem {

		driver := &driverItem{}
		driver.Get = func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				if item.Params == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				indexes := item.Params.Indexes
				if len(indexes) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				for _, indexStr := range indexes {
					indexN := strings.Split(indexStr, "-")
					switch len(indexN) {
					case 1:
						index, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						if index < 0 || index >= len(virtualDevice.Regs[reg]) {
							response.Values = append(response.Values, nil)
						} else {
							response.Values = append(response.Values, virtualDevice.Regs[reg][index])
						}
					case 2:
						index0, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						index1, err := strconv.Atoi(indexN[1])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						for index := index0; index <= index1; index++ {
							if index < 0 || index >= len(virtualDevice.Regs[reg]) {
								response.Values = append(response.Values, nil)
							} else {
								response.Values = append(response.Values, virtualDevice.Regs[reg][index])
							}
						}
					default:
						response.Code = nclinkmodel.NG
						return response, false
					}
				}
				response.Code = nclinkmodel.OK
				return response, true
			case nclinkmodel.OP_get_length:
				response.Values = append(response.Values, len(virtualDevice.Regs[reg]))
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		}
		driver.Set = func(item nclinkmodel.SetItem, virtualDevice *virtualMachine) (item2 *nclinkmodel.SetItem, b bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_set_value
			}
			switch operation {
			case nclinkmodel.OP_set_value:
				index := item.Params.Index
				if item.Params.Value == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				if index == nil || *index < 0 || *index >= len(virtualDevice.Regs[reg]) {
					response.Code = nclinkmodel.NG
					return response, false
				}
				value, ok := item.Params.Value.(float64)
				if !ok {
					response.Code = nclinkmodel.NG
					return response, false
				}
				virtualDevice.Regs[reg][*index] = uint32(value)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		}
		driver.Sample = nil
		return driver
	}

	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_X"] = regDriver(0)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_Y"] = regDriver(1)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_F"] = regDriver(2)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_G"] = regDriver(3)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_R"] = regDriver(4)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_B"] = regDriver(5)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_W"] = regDriver(6)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_D"] = regDriver(7)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_P"] = regDriver(8)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_I"] = regDriver(9)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_Q"] = regDriver(10)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_K"] = regDriver(11)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_T"] = regDriver(12)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#REG_C"] = regDriver(13)

	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:PARAMETER"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, dev *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if dev == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				if item.Params == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				indexes := item.Params.Indexes
				if len(indexes) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Params.Indexes = indexes
				for _, indexStr := range indexes {
					indexN := strings.Split(indexStr, "-")
					switch len(indexN) {
					case 1:
						index, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						response.Values = append(response.Values, dev.paramGetValue(index))
					case 2:
						index0, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						index1, err := strconv.Atoi(indexN[1])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						for index := index0; index <= index1; index++ {
							response.Values = append(response.Values, dev.paramGetValue(index))
						}
					default:
						response.Code = nclinkmodel.NG
						return response, false
					}
				}
				response.Code = nclinkmodel.OK
				return response, true
			case nclinkmodel.OP_get_length:
				response.Values = append(response.Values, dev.paramGetLength())
				response.Code = nclinkmodel.OK
				return response, true
			case nclinkmodel.OP_get_attributes:
				if item.Params == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				indexes := item.Params.Indexes
				if len(indexes) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Params.Indexes = indexes
				for _, indexStr := range indexes {
					indexN := strings.Split(indexStr, "-")
					switch len(indexN) {
					case 1:
						index, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						response.Values = append(response.Values, dev.paramGetAttribute(index))
					case 2:
						index0, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						index1, err := strconv.Atoi(indexN[1])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						for index := index0; index <= index1; index++ {
							response.Values = append(response.Values, dev.paramGetAttribute(index))
						}
					default:
						response.Code = nclinkmodel.NG
						return response, false
					}
				}
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: func(item nclinkmodel.SetItem, dev *virtualMachine) (item2 *nclinkmodel.SetItem, b bool) {
			response := &item
			if dev == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_set_value
			}
			switch operation {
			case nclinkmodel.OP_set_value:
				index := item.Params.Index
				if index == nil || *index < 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				if item.Params.Value == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				value := item.Params.Value
				state := dev.paramSetValue(*index, value)
				if state {
					response.Code = nclinkmodel.OK
					return response, true
				} else {
					response.Code = nclinkmodel.NG
					return response, true
				}
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Sample: nil,
	}
	dataDriver := func(data int) *driverItem {
		driver := &driverItem{}
		driver.Get = func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				if item.Params == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				indexes := item.Params.Indexes
				if len(indexes) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Params.Indexes = indexes
				for _, indexStr := range indexes {
					indexN := strings.Split(indexStr, "-")
					switch len(indexN) {
					case 1:
						index, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						if index < 0 || index >= len(axisChanSystemData[data]) {
							response.Code = nclinkmodel.NG
							return response, false
						} else {
							response.Values = append(response.Values, axisChanSystemData[data][index])
						}
					case 2:
						index0, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						index1, err := strconv.Atoi(indexN[1])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						for index := index0; index <= index1; index++ {
							if index < 0 || index >= len(axisChanSystemData[data]) {
								response.Code = nclinkmodel.NG
								return response, false
							} else {
								response.Values = append(response.Values, axisChanSystemData[data][index])
							}
						}
					default:
						response.Code = nclinkmodel.NG
						return response, false
					}
				}
				response.Code = nclinkmodel.OK
				return response, true
			case nclinkmodel.OP_get_length:
				response.Values = append(response.Values, len(axisChanSystemData[data]))
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		}
		driver.Set = func(item nclinkmodel.SetItem, virtualDevice *virtualMachine) (item2 *nclinkmodel.SetItem, b bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_set_value
			}
			switch operation {
			case nclinkmodel.OP_set_value:
				index := item.Params.Index
				if item.Params.Value == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				if index == nil || *index < 0 || *index >= len(axisChanSystemData[data]) {
					response.Code = nclinkmodel.NG
					return response, false
				}
				value, ok := item.Params.Value.(float64)
				if !ok {
					response.Code = nclinkmodel.NG
					return response, false
				}
				axisChanSystemData[data][*index] = uint32(value)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		}
		driver.Sample = nil
		return driver
	}

	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#AXIS_0"] = dataDriver(0)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#AXIS_1"] = dataDriver(1)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#AXIS_2"] = dataDriver(2)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#AXIS_5"] = dataDriver(5)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#CHAN_0"] = dataDriver(6)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#SYS"] = dataDriver(10)
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#VAR_SYS"] = drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#SYS"]
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#VAR_CHAN_0"] = drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#CHAN_0"]

	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:COORDINATE"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				if item.Params == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				indexes := item.Params.Indexes
				if len(indexes) == 0 {
					response.Code = nclinkmodel.NG
					return response, false
				}
				response.Params.Indexes = indexes
				for _, indexStr := range indexes {
					indexN := strings.Split(indexStr, "-")
					switch len(indexN) {
					case 1:
						index, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						if index < 0 || index >= len(virtualDevice.Crds) {
							response.Code = nclinkmodel.NG
							return response, false
						} else {
							response.Values = append(response.Values, virtualDevice.Crds[index])
						}
					case 2:
						index0, err := strconv.Atoi(indexN[0])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						index1, err := strconv.Atoi(indexN[1])
						if err != nil {
							response.Code = nclinkmodel.NG
							return response, false
						}
						for index := index0; index <= index1; index++ {
							if index < 0 || index >= len(virtualDevice.Crds) {
								response.Values = append(response.Values, nil)
							} else {
								response.Values = append(response.Values, virtualDevice.Crds[index])
							}
						}
					default:
						response.Code = nclinkmodel.NG
						return response, false
					}
				}
				response.Code = nclinkmodel.OK
				return response, true
			case nclinkmodel.OP_get_length:
				response.Values = append(response.Values, len(virtualDevice.Crds))
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Set: func(item nclinkmodel.SetItem, virtualDevice *virtualMachine) (item2 *nclinkmodel.SetItem, b bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_set_value
			}
			switch operation {
			case nclinkmodel.OP_set_value:
				index := item.Params.Index
				if index == nil || *index < 0 || *index >= len(virtualDevice.Crds) {
					response.Code = nclinkmodel.NG
					return response, false
				}
				if item.Params.Value == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				value, ok := item.Params.Value.(map[string]interface{})
				if !ok {
					response.Code = nclinkmodel.NG
					return response, false
				}
				for k, v := range value {
					switch k {
					case "x":
						*virtualDevice.Crds[*index].X = float32(v.(float64))
					case "y":
						*virtualDevice.Crds[*index].Y = float32(v.(float64))
					case "z":
						*virtualDevice.Crds[*index].Z = float32(v.(float64))
					case "c":
						*virtualDevice.Crds[*index].C = float32(v.(float64))
					}
				}
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:CONSOLE"] = &driverItem{
		PrivilegeLevel: 0,
		Get:            nil,
		Set: func(item nclinkmodel.SetItem, virtualDevice *virtualMachine) (item2 *nclinkmodel.SetItem, b bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_set_value
			}
			switch operation {
			case nclinkmodel.OP_set_value:
				if item.Params.Value == nil {
					response.Code = nclinkmodel.NG
					return response, false
				}
				value, ok := item.Params.Value.(string)
				if !ok {
					response.Code = nclinkmodel.NG
					return response, false
				}
				if len(value) == 0 {
					response.Code = nclinkmodel.NG
					response.Reason = nclinkmodel.Reason_Format_Wrong
				} else {
					cmds := strings.Split(value, " ")
					result, err := exec.Command(cmds[0], cmds[1:]...).Output()
					if err == nil {
						response.Code = nclinkmodel.OK
						response.Reason = string(result)
					} else {
						response.Code = nclinkmodel.NG
						response.Reason = err.Error()
					}

				}
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}
		},
		Sample: nil,
	}
	drivers["NC_LINK_ROOT:MACHINE:CONTROLLER:VARIABLE#PROGID_MAP"] = &driverItem{
		PrivilegeLevel: 0,
		Get: func(item nclinkmodel.QueryItem, virtualDevice *virtualMachine) (*nclinkmodel.QueryItem, bool) {
			response := &item
			if virtualDevice == nil {
				response.Code = nclinkmodel.NG
				return response, false
			}
			var operation string
			if item.Params != nil && item.Params.Operation != "" {
				operation = item.Params.Operation
			} else {
				operation = nclinkmodel.OP_get_value
			}
			switch operation {
			case nclinkmodel.OP_get_value:
				myMap := map[int]string{}
				for i := 0; i < len(virtualDevice.ProgList); i++ {
					myMap[i] = virtualDevice.ProgList[i].name
				}
				response.Values = append(response.Values, myMap)
				response.Code = nclinkmodel.OK
				return response, true
			default:
				response.Code = nclinkmodel.NG
				return response, false
			}

		},
		Set:    nil,
		Sample: nil,
	}
}