package js

import (
	"bytes"
	"encoding/hex"
	"encoding/json"
	"github.com/dop251/goja"
	"github.com/ssgo/u"
	"gopkg.in/yaml.v3"
	"text/template"
)

func RequireUtil() map[string]any {
	return map[string]any{
		"json": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
				return vm.ToValue(string(r))
			} else {
				return vm.NewGoError(err)
			}
		},
		"jsonP": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
				r1 := bytes.Buffer{}
				if err2 := json.Indent(&r1, r, "", "  "); err2 == nil {
					return vm.ToValue(string(r))
				} else {
					return vm.ToValue(string(r))
				}
			} else {
				return vm.NewGoError(err)
			}
		},
		"unJson": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			var r any
			if err := json.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
				return vm.ToValue(r)
			} else {
				return vm.NewGoError(err)
			}
		},
		"yaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			if r, err := yaml.Marshal(args.Arguments[0].Export()); err == nil {
				return vm.ToValue(string(r))
			} else {
				return vm.NewGoError(err)
			}
		},
		"unYaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			var r any
			if err := yaml.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
				return vm.ToValue(r)
			} else {
				return vm.NewGoError(err)
			}
		},
		"base64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.Base64(u.Bytes(args.Arguments[0].Export())))
		},
		"unBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.UnBase64String(args.Str(0)))
		},
		"urlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.UrlBase64String(args.Str(0)))
		},
		"unUrlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.UnUrlBase64String(args.Str(0)))
		},
		"hex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(hex.EncodeToString(u.Bytes(args.Arguments[0].Export())))
		},
		"unHex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			if r, err := hex.DecodeString(args.Str(0)); err == nil {
				return vm.ToValue(string(r))
			} else {
				return vm.NewGoError(err)
			}
		},
		"aes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(3); err != nil {
				return err
			}

			if r, err := u.EncryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
				return vm.ToValue(string(r))
			} else {
				return vm.NewGoError(err)
			}
		},
		"unAes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(3); err != nil {
				return err
			}

			if r, err := u.DecryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
				return vm.ToValue(string(r))
			} else {
				return vm.NewGoError(err)
			}
		},
		"gzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			if r, err := u.Gzip(u.Bytes(args.Arguments[0].Export())); err == nil {
				return vm.ToValue(string(r))
			} else {
				return vm.NewGoError(err)
			}
		},
		"gunzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			if r, err := u.Gunzip(u.Bytes(args.Arguments[0].Export())); err == nil {
				return vm.ToValue(string(r))
			} else {
				return vm.NewGoError(err)
			}
		},
		"id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(u.Id12())
		},
		"uniqueId": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(u.UniqueId())
		},
		"token": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			size := 20
			if len(argsIn.Arguments) > 0 {
				size = u.Int(argsIn.Arguments[0].Export())
			}
			return vm.ToValue(u.MakeToken(size))
		},
		"md5": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.MD5(u.Bytes(args.Arguments[0].Export())))
		},
		"sha1": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.Sha1(u.Bytes(args.Arguments[0].Export())))
		},
		"sha256": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.Sha256(u.Bytes(args.Arguments[0].Export())))
		},
		"sha512": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			return vm.ToValue(u.Sha512(u.Bytes(args.Arguments[0].Export())))
		},
		"tpl": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(2); err != nil {
				return err
			}

			var functions = map[string]any{}
			if len(argsIn.Arguments) > 2 {
				obj := argsIn.Arguments[2].ToObject(vm)
				for _, k := range obj.Keys() {
					v := obj.Get(k)
					if cb, ok := goja.AssertFunction(v); ok {
						functions[k] = func(in string) string {
							if r, err := cb(argsIn.This, vm.ToValue(in)); err == nil {
								return r.String()
							}
							return ""
						}
					}
				}
			}

			buf := bytes.NewBuffer(make([]byte, 0))
			var err error
			tpl := template.New("tpl")
			if len(functions) > 0 {
				tpl.Funcs(functions)
			}
			if tpl, err = tpl.Parse(args.Str(0)); err == nil {
				err = tpl.Execute(buf, args.Arguments[1].Export())
			}
			if err != nil {
				return vm.NewGoError(err)
			}
			return vm.ToValue(buf.String())
		},
		"shell": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := MakeArgs(&argsIn, vm)
			if err := args.Check(1); err != nil {
				return err
			}

			a := make([]string, len(args.Arguments)-1)
			for i := 1; i < len(args.Arguments); i++ {
				a[i-1] = args.Str(i)
			}

			if r, err := u.RunCommand(args.Str(0), a...); err == nil {
				return vm.ToValue(r)
			} else {
				return vm.NewGoError(err)
			}
		},
	}
}