package driver

import (
	"bytes"
	"encoding/binary"
	"encoding/xml"
	"fmt"
	"io/ioutil"
	"os"
	"strconv"
	"strings"
)

const (
	fileHeadSize      = 180
	paramFileHeadSize = 32
	paramValueSize    = 8
)
const (
	ncunum   = 1
	macnum   = 1
	channum  = 4
	axesnum  = 32
	acmpnum  = axesnum
	cfgnum   = 80
	tablenum = 1
)
const (
	ncnParamnum   = 2000
	macParamNum   = 2000
	chanParamNum  = 1000
	axesParamNum  = 1000
	acmpParamNum  = 500
	cfgParamNum   = 32
	tableParamNum = 20000
)

//type rawFileHead [fileHeadSize]byte
//type rawParamFileHead [paramFileHeadSize]byte
//type rawParamValue [paramValueSize]byte
// type fileHead struct {
// 	FileFlag     [4]byte
// 	Version      int32
// 	FileInfoAddr int32
// 	FileDataAddr int32
// 	VerifyType   int32
// 	VerifyCode   [8]int32
// 	Reserve      [32]int32
// }
// type paramFileHead struct {
// 	HeadInfoSize uint32
// 	MajorVersion uint32
// 	MinorVersion uint32
// 	DataSize     uint32
// 	ChkSum       uint32
// 	UserVer      int32
// 	Reserved     [2]uint32
// }
type paramValue struct {
	id        int
	attribute paramAttri
	value     interface{}
	raw       [paramValueSize]byte
}

// type paramSubLib struct {
// 	ParamItems []paramValue
// }

var paramDefine paramDef

const (
	ncu = iota
	mac
	channel
	axes
	acmp
	cfg
	table
)

// type paramManager struct {
// 	NCU   [ncnParamnum]paramValue
// 	MAC   [macParamNum]paramValue
// 	CHAN  [4 * chanParamNum]paramValue
// 	AXES  [32 * axesParamNum]paramValue
// 	ACMP  [acmpParamNum]paramValue
// 	CFG   [80 * cfgParamNum]paramValue
// 	TABLE [tableParamNum]paramValue
// }

type paramDef struct {
	XMLName xml.Name
	Version string `xml:"version,attr"`
	Lib     []lib  `xml:"LIB"`
}
type lib struct {
	XMLName xml.Name
	Type    string `xml:"type,attr"`
	Name    string `xml:"name,attr"`
	SubName string `xml:"subname,attr"`
	StartId string `xml:"startid,attr"`
	ParmNum string `xml:"parmnum,attr"`
	SubNum  string `xml:"subnum,attr"`
	Item    []item `xml:"item"`
}
type item struct {
	XMLName   xml.Name
	Id        string   `xml:"id,attr"`
	Name      string   `xml:"name,attr"`
	Dimension string   `xml:"dimension,attr"`
	Right     string   `xml:"right,attr"`
	ActType   string   `xml:"acttype,attr"`
	StoreType string   `xml:"storetype,attr"`
	Default   string   `xml:"def,attr"`
	Min       string   `xml:"min,attr"`
	Max       string   `xml:"max,attr"`
	SubLib    []sublib `xml:"sublib"`
}
type sublib struct {
	XMLName xml.Name
	Index   string `xml:"index,attr"`
	Name    string `xml:"name,attr"`
	Value   string `xml:"value,attr"`
	Item    []item `xml:"item"`
}
type paramAttri struct {
	Name    string      `json:"name"`
	Max     interface{} `json:"max_value,omitempty"`
	Min     interface{} `json:"min_value,omitempty"`
	Default interface{} `json:"default_value,omitempty"`
	Act     int         `json:"action_type,omitempty"`
}

func (_this *virtualMachine) paramGetValue(id int) interface{} {
	switch {
	case id >= 0 && id < 10000:
		if id >= ncnParamnum {
			return nil
		} else {
			return _this.paramItems[0][0][id].value
		}
	case id >= 10000 && id < 40000:
		id %= 10000
		if id >= macParamNum {
			return nil
		} else {
			return _this.paramItems[1][0][id].value
		}
	case id >= 40000 && id < 100000:
		id %= 40000
		ch := id / 1000
		if ch >= channum {
			return nil
		}
		id %= 1000
		if id >= chanParamNum {
			return nil
		} else {
			return _this.paramItems[2][ch][id].value
		}
	case id >= 100000 && id < 300000:
		id %= 100000
		ax := id / 1000
		if ax >= axesnum {
			return nil
		}
		id %= 1000
		if id >= axesParamNum {
			return nil
		} else {
			return _this.paramItems[2][ax][id].value
		}
	case id >= 300000 && id < 500000:
		id %= 300000
		acmp := id / 1000
		if acmp >= acmpnum {
			return nil
		}
		id %= 1000
		if id >= acmpParamNum {
			return nil
		} else {
			return _this.paramItems[2][acmp][id].value
		}
	case id >= 500000 && id < 700000:
		id %= 500000
		cfg := id / 1000
		if cfg >= cfgnum {
			return nil
		}
		id %= 1000
		if id >= cfgParamNum {
			return nil
		} else {
			return _this.paramItems[2][cfg][id].value
		}
	}
	return nil
}
func (_this *virtualMachine) paramGetAttribute(id int) interface{} {
	switch {
	case id >= 0 && id < 10000:
		if id >= ncnParamnum || _this.paramItems[0][0][id].value == nil {
			return nil
		} else {
			return _this.paramItems[0][0][id].attribute
		}
	case id >= 10000 && id < 40000:
		id %= 10000
		if id >= macParamNum || _this.paramItems[1][0][id].value == nil {
			return nil
		} else {
			return _this.paramItems[1][0][id].attribute
		}
	case id >= 40000 && id < 100000:
		id %= 40000
		ch := id / 1000
		if ch >= channum {
			return nil
		}
		id %= 1000
		if id >= chanParamNum || _this.paramItems[2][ch][id].value == nil {
			return nil
		} else {
			return _this.paramItems[2][ch][id].attribute
		}
	case id >= 100000 && id < 300000:
		id %= 100000
		ax := id / 1000
		if ax >= axesnum {
			return nil
		}
		id %= 1000
		if id >= axesParamNum || _this.paramItems[2][ax][id].value == nil {
			return nil
		} else {
			return _this.paramItems[2][ax][id].attribute
		}
	case id >= 300000 && id < 500000:
		id %= 300000
		acmp := id / 1000
		if acmp >= acmpnum {
			return nil
		}
		id %= 1000
		if id >= acmpParamNum || _this.paramItems[2][acmp][id].value == nil {
			return nil
		} else {
			return _this.paramItems[2][acmp][id].attribute
		}
	case id >= 500000 && id < 700000:
		id %= 500000
		cfg := id / 1000
		if cfg >= cfgnum {
			return nil
		}
		id %= 1000
		if id >= cfgParamNum || _this.paramItems[2][cfg][id].value == nil {
			return nil
		} else {
			return _this.paramItems[2][cfg][id].attribute
		}
	}
	return nil
}
func (_this *virtualMachine) paramGetLength() int {
	return 700000
}
func (_this *virtualMachine) paramSetValue(id int, value interface{}) bool {
	if value == nil {
		return false
	}
	switch {
	case id >= 0 && id < 10000:
		if id >= ncnParamnum {
			return false
		} else {
			_this.paramItems[0][0][id].value = value
			return true
		}
	case id >= 10000 && id < 40000:
		id %= 10000
		if id >= macParamNum {
			return false
		} else {
			_this.paramItems[0][0][id].value = value
			return true
		}
	case id >= 40000 && id < 100000:
		id %= 40000
		ch := id / 1000
		if ch >= channum {
			return false
		}
		id %= 1000
		if id >= chanParamNum {
			return false
		} else {
			_this.paramItems[2][ch][id].value = value
			return true
		}
	case id >= 100000 && id < 300000:
		id %= 100000
		ax := id / 1000
		if ax >= axesnum {
			return false
		}
		id %= 1000
		if id >= axesParamNum {
			return false
		} else {
			_this.paramItems[2][ax][id].value = value
			return true
		}
	case id >= 300000 && id < 500000:
		id %= 300000
		acmp := id / 1000
		if acmp >= acmpnum {
			return false
		}
		id %= 1000
		if id >= acmpParamNum {
			return false
		} else {
			_this.paramItems[2][acmp][id].value = value
			return true
		}
	case id >= 500000 && id < 700000:
		id %= 500000
		cfg := id / 1000
		if cfg >= cfgnum {
			return false
		}
		id %= 1000
		if id >= cfgParamNum {
			return false
		} else {
			_this.paramItems[2][cfg][id].value = false
			return true
		}
	}
	return false
}
func (_this *virtualMachine) paramInit(workDir string) bool {
	paramDataFile := fmt.Sprintf("%s%s", workDir, "/param/818BM.DAT")
	paramDefineFile := fmt.Sprintf("%s%s", workDir, "/param/PARM-CN.XML")
	dataFile, err := os.Open(paramDataFile)
	if err != nil {
		fmt.Printf("Failed to Open File:%v", err.Error())
		return false
	}
	defer dataFile.Close()
	fileHeadBuffer := make([]byte, fileHeadSize)
	n, err := dataFile.Read(fileHeadBuffer)
	if err != nil {
		fmt.Printf("Failed to Read File Head:%v", err.Error())
		return false
	}
	if n != fileHeadSize {
		fmt.Printf("Failed to Read File Head")
		return false
	}
	paramFileHeadBuffer := make([]byte, paramFileHeadSize)
	n, err = dataFile.Read(paramFileHeadBuffer)
	if err != nil {
		fmt.Printf("Failed to Read Param File Head:%v", err.Error())
		return false
	}
	if n != paramFileHeadSize {
		fmt.Printf("Failed to Read File Head")
		return false
	}
	_this.paramItems = make([][][]paramValue, 7)
	_this.paramItems[ncu] = make([][]paramValue, ncunum)
	for i := 0; i < ncunum; i++ {
		_this.paramItems[ncu][i] = make([]paramValue, ncnParamnum)
	}
	_this.paramItems[mac] = make([][]paramValue, macnum)
	for i := 0; i < macnum; i++ {
		_this.paramItems[mac][i] = make([]paramValue, macParamNum)
	}
	_this.paramItems[channel] = make([][]paramValue, channum)
	for i := 0; i < channum; i++ {
		_this.paramItems[channel][i] = make([]paramValue, chanParamNum)
	}
	_this.paramItems[axes] = make([][]paramValue, axesnum)
	for i := 0; i < axesnum; i++ {
		_this.paramItems[axes][i] = make([]paramValue, axesParamNum)
	}
	_this.paramItems[acmp] = make([][]paramValue, acmpnum)
	for i := 0; i < acmpnum; i++ {
		_this.paramItems[acmp][i] = make([]paramValue, acmpParamNum)
	}
	_this.paramItems[cfg] = make([][]paramValue, cfgnum)
	for i := 0; i < cfgnum; i++ {
		_this.paramItems[cfg][i] = make([]paramValue, cfgParamNum)
	}
	_this.paramItems[table] = make([][]paramValue, tablenum)
	for i := 0; i < tablenum; i++ {
		_this.paramItems[table][i] = make([]paramValue, tableParamNum)
	}
	for i := 0; i < len(_this.paramItems); i++ {
		for j := 0; j < len(_this.paramItems[i]); j++ {
			for k := 0; k < len(_this.paramItems[i][j]); k++ {
				n, err = dataFile.Read(_this.paramItems[i][j][k].raw[:])
				if err != nil {
					fmt.Printf("Failed to Read Param Value:%v", err.Error())
					return false
				}
				if n != paramValueSize {
					fmt.Printf("Failed to Read File")
					return false
				}
			}
		}
	}
	data, err := ioutil.ReadFile(paramDefineFile)
	if err != nil {
		fmt.Printf("Failed to Read Param Define File:%v", err.Error())
		return false
	}
	err = xml.Unmarshal(data, &paramDefine)
	if err != nil {
		fmt.Printf("Failed to Parse Param Define File:%v", err)
	}
	for i := 0; i < len(paramDefine.Lib); i++ {
		if i >= len(_this.paramItems) {
			continue
		}
		lib := paramDefine.Lib[i]
		libParamItems := _this.paramItems[i]
		if lib.Item == nil {
			continue
		}
		startId, err := strconv.Atoi(lib.StartId)
		if err != nil {
			continue
		}
		for j := 0; j < len(paramDefine.Lib[i].Item); j++ {
			item := paramDefine.Lib[i].Item[j]
			dimension, _ := strconv.Atoi(item.Dimension)
			if dimension > 0 {
				continue
			}
			index, err := strconv.Atoi(item.Id)
			if err != nil {
				continue
			}
			index -= startId
			if index < 0 || index >= len(libParamItems[0]) {
				continue
			}
			var m, n int
			switch i {
			case ncu:
				m = ncunum
				n = ncnParamnum
			case mac:
				m = macnum
				n = macParamNum
			case channel:
				m = channum
				n = chanParamNum
			case axes:
				m = axesnum
				n = axesParamNum
			case acmp:
				m = acmpnum
				n = acmpParamNum
			case cfg:
				m = cfgnum
				n = cfgParamNum
			case table:
				m = tablenum
				n = tableParamNum
			}
			if index >= n {
				continue
			}
			for u := 0; u < m; u++ {
				paramItem := &libParamItems[u][index]
				paramItem.id = startId + index + u*1000
				paramItem.attribute.Name = item.Name
				switch item.ActType {
				case "ACT_SAVE":
					paramItem.attribute.Act = 0
				case "ACT_NOW":
					paramItem.attribute.Act = 1
				case "ACT_RST":
					paramItem.attribute.Act = 2
				case "ACT_PWR":
					paramItem.attribute.Act = 3
				case "ACT_HIDE":
					paramItem.attribute.Act = 4
				}
				byteReader := bytes.NewReader(paramItem.raw[:])
				if strings.HasPrefix(item.StoreType, "STRING") {
					w := 0
					for ; w < 8; w++ {
						if paramItem.raw[w] == 0 {
							break
						}
					}
					paramItem.value = string(paramItem.raw[0:w])
				} else {
					switch item.StoreType {
					case "BOOL", "UINT1":
						paramItem.value = new(uint8)
						if len(item.Default) != 0 {
							paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
						}
						if len(item.Max) != 0 {
							paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
						}
						if len(item.Min) != 0 {
							paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
						}
					case "INT1":
						paramItem.value = new(int8)
						if len(item.Default) != 0 {
							paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
						}
						if len(item.Max) != 0 {
							paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
						}
						if len(item.Min) != 0 {
							paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
						}
					case "UINT2":
						paramItem.value = new(uint16)
						if len(item.Default) != 0 {
							paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
						}
						if len(item.Max) != 0 {
							paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
						}
						if len(item.Min) != 0 {
							paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
						}
					case "INT2":
						paramItem.value = new(int16)
						if len(item.Default) != 0 {
							paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
						}
						if len(item.Max) != 0 {
							paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
						}
						if len(item.Min) != 0 {
							paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
						}
					case "UINT4":
						paramItem.value = new(uint32)
						if len(item.Default) != 0 {
							paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
						}
						if len(item.Max) != 0 {
							paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
						}
						if len(item.Min) != 0 {
							paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
						}
					case "INT4", "HEX4":
						paramItem.value = new(int32)
						if len(item.Default) != 0 {
							paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
						}
						if len(item.Max) != 0 {
							paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
						}
						if len(item.Min) != 0 {
							paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
						}
					case "REAL", "INTEXP":
						paramItem.value = new(float64)
						if len(item.Default) != 0 {
							paramItem.attribute.Default, _ = strconv.ParseFloat(item.Default, 64)
						}
						if len(item.Max) != 0 {
							paramItem.attribute.Max, _ = strconv.ParseFloat(item.Max, 64)
						}
						if len(item.Min) != 0 {
							paramItem.attribute.Min, _ = strconv.ParseFloat(item.Min, 64)
						}
					case "BYTE[8]", "BYTE[4]":
						paramItem.value = new([8]byte)
					}
					err = binary.Read(byteReader, binary.LittleEndian, paramItem.value)
					if err != nil {
						continue
					}
				}
			}
		}
	}

	for i := 0; i < len(paramDefine.Lib); i++ {
		if i >= len(_this.paramItems) {
			break
		}
		lib := paramDefine.Lib[i]
		if lib.Item == nil {
			continue
		}
		startId, err := strconv.Atoi(lib.StartId)
		if err != nil {
			continue
		}
		if i != axes && i != cfg {
			continue
		}
		for j := 0; j < len(paramDefine.Lib[i].Item); j++ {
			item := paramDefine.Lib[i].Item[j]
			dimension, _ := strconv.Atoi(item.Dimension)
			if dimension <= 0 || item.SubLib == nil || len(item.SubLib) == 0 {
				continue
			}

			for k := 0; k < len(item.SubLib); k++ {
				if len(item.SubLib[k].Value) == 0 {
					continue
				}
				subItems := item.SubLib[k].Item
				if subItems == nil {
					continue
				}
				subValue, err := strconv.Atoi(item.SubLib[k].Value)
				if err != nil {
					continue
				}
				var subParamItems []paramValue
				var num, target int
				if i == axes {
					num = axesnum
					for l := 0; l < num; l++ {
						typeValue := _this.paramItems[i][l][1].value
						if typeValue == nil {
							continue
						}
						typeNumber := *typeValue.(*uint8)
						if subValue == int(typeNumber) {
							subParamItems = _this.paramItems[i][l]
							target = l
							for l := 0; l < len(subItems); l++ {
								subItem := subItems[l]
								dimension, _ := strconv.Atoi(subItem.Dimension)
								if dimension > 0 {
									continue
								}
								index, err := strconv.Atoi(subItem.Id)
								if err != nil {
									continue
								}
								index -= startId
								if index < 0 || index >= len(subParamItems) {
									continue
								}
								paramItem := &subParamItems[index]
								paramItem.id = startId + index + target*1000
								paramItem.attribute.Name = item.Name
								switch item.ActType {
								case "ACT_SAVE":
									paramItem.attribute.Act = 0
								case "ACT_NOW":
									paramItem.attribute.Act = 1
								case "ACT_RST":
									paramItem.attribute.Act = 2
								case "ACT_PWR":
									paramItem.attribute.Act = 3
								case "ACT_HIDE":
									paramItem.attribute.Act = 4
								}
								byteReader := bytes.NewReader(paramItem.raw[:])
								if strings.HasPrefix(item.StoreType, "STRING") {
									w := 0
									for ; w < 8; w++ {
										if paramItem.raw[w] == 0 {
											break
										}
									}
									paramItem.value = string(paramItem.raw[0:w])
								} else {
									switch item.StoreType {
									case "BOOL", "UINT1":
										paramItem.value = new(uint8)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}

									case "INT1":
										paramItem.value = new(int8)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "UINT2":
										paramItem.value = new(uint16)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "INT2":
										paramItem.value = new(int16)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "UINT4":
										paramItem.value = new(uint32)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "INT4", "HEX4":
										paramItem.value = new(int32)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "REAL", "INTEXP":
										paramItem.value = new(float64)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.ParseFloat(item.Default, 64)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Default, _ = strconv.ParseFloat(item.Default, 64)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Default, _ = strconv.ParseFloat(item.Default, 64)
										}
									case "BYTE":
										paramItem.value = new([8]byte)
									}
									err = binary.Read(byteReader, binary.LittleEndian, paramItem.value)
									if err != nil {
										continue
									}
								}
							}
						}
					}
				} else if i == cfg {
					num = cfgnum
					for l := 0; l < num; l++ {
						typeValue := _this.paramItems[i][l][2].value
						if typeValue == nil {
							continue
						}
						typeNumber := *typeValue.(*int32)
						if subValue == int(typeNumber) {
							subParamItems = _this.paramItems[i][l]
							target = l
							for l := 0; l < len(subItems); l++ {
								subItem := subItems[l]
								dimension, _ := strconv.Atoi(subItem.Dimension)
								if dimension > 0 {
									continue
								}
								index, err := strconv.Atoi(subItem.Id)
								if err != nil {
									continue
								}
								index -= startId
								if index < 0 || index >= len(subParamItems) {
									continue
								}
								paramItem := &subParamItems[index]
								paramItem.id = startId + index + target*1000
								paramItem.attribute.Name = item.Name
								switch item.ActType {
								case "ACT_SAVE":
									paramItem.attribute.Act = 0
								case "ACT_NOW":
									paramItem.attribute.Act = 1
								case "ACT_RST":
									paramItem.attribute.Act = 2
								case "ACT_PWR":
									paramItem.attribute.Act = 3
								case "ACT_HIDE":
									paramItem.attribute.Act = 4
								}
								byteReader := bytes.NewReader(paramItem.raw[:])
								if strings.HasPrefix(item.StoreType, "STRING") {
									w := 0
									for ; w < 8; w++ {
										if paramItem.raw[w] == 0 {
											break
										}
									}
									paramItem.value = string(paramItem.raw[0:w])
								} else {
									switch item.StoreType {
									case "BOOL", "UINT1":
										paramItem.value = new(uint8)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "INT1":
										paramItem.value = new(int8)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "UINT2":
										paramItem.value = new(uint16)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "INT2":
										paramItem.value = new(int16)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "UINT4":
										paramItem.value = new(uint32)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "INT4", "HEX4":
										paramItem.value = new(int32)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.Atoi(item.Default)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Max, _ = strconv.Atoi(item.Max)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Min, _ = strconv.Atoi(item.Min)
										}
									case "REAL", "INTEXP":
										paramItem.value = new(float64)
										if len(item.Default) != 0 {
											paramItem.attribute.Default, _ = strconv.ParseFloat(item.Default, 64)
										}
										if len(item.Max) != 0 {
											paramItem.attribute.Default, _ = strconv.ParseFloat(item.Default, 64)
										}
										if len(item.Min) != 0 {
											paramItem.attribute.Default, _ = strconv.ParseFloat(item.Default, 64)
										}
									case "BYTE":
										paramItem.value = new([8]byte)
									}
									err = binary.Read(byteReader, binary.LittleEndian, paramItem.value)
									if err != nil {
										continue
									}
								}
							}
						}
					}
				} else {
					continue
				}
			}
		}
	}
	return true
}