encoding

var B64Decode = rnt.NewSimpleFunction("b64decode",
	[]string{"s", "url"}, func(args []rnt.Object) rnt.Object {
		var bytes []byte
		if args[0].IsInstance(rnt.BytesType) {
			bytes = args[0].(rnt.Bytes).Value()
		} else {
			bytes = []byte(args[0].(rnt.Str).Value())
		}
		enc := base64.StdEncoding
		if args[1].(rnt.Int).Value() != 0 {
			enc = base64.URLEncoding
		}
		result := make([]byte, enc.DecodedLen(len(bytes)))
		n, err := enc.Decode(result, bytes)
		if err != nil {
			panic(rnt.RaiseType(BinasciiErrorType, "Invalid base64 input"))
		}
		return rnt.NewBytes(result[:n]...)
	})

var B64Encode = rnt.NewSimpleFunction("b64encode",
	[]string{"s", "url"}, func(args []rnt.Object) rnt.Object {
		bytes := args[0].(rnt.Bytes).Value()
		enc := base64.StdEncoding
		if args[1].(rnt.Int).Value() != 0 {
			enc = base64.URLEncoding
		}
		result := make([]byte, enc.EncodedLen(len(bytes)))
		enc.Encode(result, bytes)
		return rnt.NewBytes(result...)
	})

var BinasciiErrorType = rnt.Cal(
	rnt.TypeType,
	rnt.NewStr("binascii.Error"),
	rnt.NewTuple(rnt.ValueErrorType),
	rnt.NewDict()).(rnt.Type)

var GetDecoder = rnt.NewSimpleFunction("getdecoder",
	[]string{"encoding"},
	func(args []rnt.Object) rnt.Object {
		encoding := args[0].(rnt.Str).Value()
		decoder := rnt.GetCodec(encoding).Decode
		return rnt.NewFunction(namifyEncoding(encoding)+"_decode", []rnt.Param{
			{Name: "s"},
			{Name: "errors", Def: rnt.NewStr("strict")},
		}, 0, false, false, func(args []rnt.Object) rnt.Object {
			res, cnt := decoder(args[0], args[1].(rnt.Str))
			return rnt.NewTuple(res, cnt)
		})
	})

var GetEncoder = rnt.NewSimpleFunction("getencoder",
	[]string{"encoding"},
	func(args []rnt.Object) rnt.Object {
		encoding := args[0].(rnt.Str).Value()
		encoder := rnt.GetCodec(encoding).Encode
		return rnt.NewFunction(namifyEncoding(encoding)+"_encode", []rnt.Param{
			{Name: "obj"},
			{Name: "errors", Def: rnt.NewStr("strict")},
		}, 0, false, false, func(args []rnt.Object) rnt.Object {
			res, cnt := encoder(args[0], args[1].(rnt.Str))
			return rnt.NewTuple(res, cnt)
		})
	})

var HTMLParse = rnt.NewSimpleFunction("HTMLParse", []string{"s", "cb_starttag"},
	func(args []rnt.Object) rnt.Object {
		s := args[0].(rnt.Str).Value()
		cbStartTag := args[1]
		doc, err := html.Parse(strings.NewReader(s))
		if err != nil {
			panic(rnt.RaiseType(HTMLParseErrorType, err.Error()))
		}
		var visit func(*html.Node)
		visit = func(n *html.Node) {
			if n.Type == html.ElementNode {
				attrs := make([]rnt.Object, len(n.Attr))
				for i, attr := range n.Attr {
					attrs[i] = rnt.NewTuple(rnt.NewStr(attr.Key), rnt.NewStr(attr.Val))
				}
				rnt.Cal(cbStartTag, rnt.NewStr(n.Data), rnt.NewList(attrs...))
			}
			for c := n.FirstChild; c != nil; c = c.NextSibling {
				visit(c)
			}
		}
		visit(doc)
		return rnt.None
	})

var HTMLParseErrorType = rnt.Cal(
	rnt.TypeType,
	rnt.NewStr("HTMLParseError"),
	rnt.NewTuple(rnt.ExceptionType),
	rnt.NewDict()).(rnt.Type)

var Hexlify = rnt.NewSimpleFunction("hexlify",
	[]string{"data"}, func(args []rnt.Object) rnt.Object {
		data := args[0].(rnt.Bytes)
		bytes := data.Value()
		result := make([]byte, hex.EncodedLen(len(bytes)))
		hex.Encode(result, bytes)
		return rnt.NewBytes(result...)
	})

var JSONDumps = rnt.NewSimpleFunction("dumps", []string{"obj"},
	func(args []rnt.Object) rnt.Object {
		obj := args[0]
		b, err := json.Marshal(jsonUnwrap(obj))
		if err != nil {
			panic(rnt.RaiseType(rnt.TypeErrorType, err.Error()))
		}
		return rnt.NewStr(string(b))
	})

var JSONLoads = rnt.NewSimpleFunction("loads", []string{"s"},
	func(args []rnt.Object) rnt.Object {
		s := args[0].(rnt.Str).Value()
		var v interface{}
		if err := json.Unmarshal([]byte(s), &v); err != nil {
			panic(rnt.RaiseType(rnt.ValueErrorType, err.Error()))
		}
		return jsonWrap(v)
	})

var Unhexlify = rnt.NewSimpleFunction("unhexlify",
	[]string{"hexstr"}, func(args []rnt.Object) rnt.Object {
		hexstr := args[0].(rnt.Bytes)
		bytes := hexstr.Value()
		result := make([]byte, hex.DecodedLen(len(bytes)))
		_, err := hex.Decode(result, bytes)
		if err != nil {
			panic(rnt.RaiseType(BinasciiErrorType, "Invalid hex input"))
		}
		return rnt.NewBytes(result...)
	})

var XMLElementInfos = rnt.NewSimpleFunction("XMLElementInfos", []string{"element"},
	func(args []rnt.Object) rnt.Object {
		el := rnt.UnwrapNative(args[0]).(*xmlElement)
		tag := rnt.NewStr(el.ee.Tag)
		text := rnt.NewStr(el.ee.Text())
		attrib := rnt.NewDict()
		for _, attr := range el.ee.Attr {
			attrib.SetItem(rnt.NewStr(attr.Key), rnt.NewStr(attr.Value))
		}
		childno := rnt.NewInt(len(el.ee.ChildElements()))
		return rnt.NewTuple(tag, text, attrib, childno)
	})

var XMLFind = rnt.NewSimpleFunction("XMLFind", []string{"element", "path"},
	func(args []rnt.Object) rnt.Object {
		el := rnt.UnwrapNative(args[0]).(*xmlElement)
		path, _ := lib.StringlikeVal(args[1])
		path = fixPath(el, path)
		resEl := el.ee.FindElement(path)
		if resEl == nil {
			return rnt.None
		}
		return rnt.NewNative(newXMLElement(el, resEl))
	})

var XMLFindAll = rnt.NewSimpleFunction("XMLFindAll", []string{"element", "path"},
	func(args []rnt.Object) rnt.Object {
		el := rnt.UnwrapNative(args[0]).(*xmlElement)
		path, _ := lib.StringlikeVal(args[1])
		path = fixPath(el, path)
		res := []rnt.Object{}
		for _, resEl := range el.ee.FindElements(path) {
			res = append(res, rnt.NewNative(newXMLElement(el, resEl)))
		}
		return rnt.NewList(res...)
	})

var XMLGetChildElement = rnt.NewSimpleFunction("XMLGetChildElement", []string{"element", "idx"},
	func(args []rnt.Object) rnt.Object {
		el := rnt.UnwrapNative(args[0]).(*xmlElement)
		idx := args[1].(rnt.Int).Value()
		children := el.ee.ChildElements()
		if idx >= len(children) {
			panic(rnt.Raise(rnt.IndexErrorType))
		}
		child := children[idx]
		return rnt.NewNative(newXMLElement(el, child))
	})

var XMLParse = rnt.NewSimpleFunction("XMLParse", []string{"data"},
	func(args []rnt.Object) rnt.Object {
		data, _ := lib.StringlikeVal(args[0])
		doc := etree.NewDocument()
		doc.ReadSettings.CharsetReader = func(charset string, input io.Reader) (io.Reader, error) {
			return input, nil
		}
		err := doc.ReadFromString(data)
		if err != nil {
			panic(rnt.RaiseType(XMLParseErrorType, err.Error()))
		}
		root := doc.Root()
		if root == nil {
			return rnt.None
		}
		return rnt.NewNative(newXMLElement(nil, root))
	})

var XMLParseErrorType = rnt.Cal(
	rnt.TypeType,
	rnt.NewStr("XMLParseError"),
	rnt.NewTuple(rnt.ExceptionType),
	rnt.NewDict()).(rnt.Type)