package code

import (
	"path"
	"strings"

	ice "shylinux.com/x/icebergs"
	"shylinux.com/x/icebergs/base/cli"
	"shylinux.com/x/icebergs/base/ctx"
	"shylinux.com/x/icebergs/base/gdb"
	"shylinux.com/x/icebergs/base/lex"
	"shylinux.com/x/icebergs/base/mdb"
	"shylinux.com/x/icebergs/base/nfs"
	"shylinux.com/x/icebergs/base/yac"
	kit "shylinux.com/x/toolkits"
)

func _go_trans(m *ice.Message, key string) string {
	switch key {
	case "m", "msg":
		key = "icebergs.Message"
	case "code", "wiki", "chat", "team", "mall":
		key = "shylinux.com/x/icebergs/core/" + key
	case "aaa", "cli", "ctx", "mdb", "nfs", "web":
		key = "shylinux.com/x/icebergs/base/" + key
	case "ice":
		key = "shylinux.com/x/icebergs"
	case "kit":
		key = "shylinux.com/x/toolkits"
	}
	return key
}
func _go_complete(m *ice.Message, arg ...string) {
	if m.Option(mdb.TEXT) == "" {
		m.Push(mdb.TEXT, PACKAGE, IMPORT, CONST, TYPE, FUNC, VAR)
	} else if strings.HasSuffix(m.Option(mdb.TEXT), nfs.PT) {
		for _, l := range strings.Split(GoDoc(m, _go_trans(m, kit.Slice(kit.Split(m.Option(mdb.TEXT), "\t ."), -1)[0])), lex.NL) {
			if ls := kit.Split(l, "\t *", "()"); len(ls) > 1 {
				kit.Switch(ls[0], []string{CONST, TYPE, FUNC, VAR}, func() {
					kit.If(ls[1] == "(", func() { m.Push(mdb.NAME, ls[5]) }, func() { m.Push(mdb.NAME, ls[1]) })
					m.Push(mdb.TEXT, l)
				})
			}
		}
	} else {
		m.Push(mdb.TEXT, "m", "msg", "code", "wiki", "chat", "team", "mall", "arg", "aaa", "cli", "ctx", "mdb", "nfs", "web", "ice", "kit")
		for _, l := range strings.Split(GoStd(m), lex.NL) {
			m.Push(mdb.TEXT, kit.Slice(kit.Split(l, nfs.PS), -1)[0])
		}
	}
}
func _go_navigate(m *ice.Message, arg ...string) {
	for _, cmd := range []string{"guru", "gopls"} {
		if ls := kit.Split(m.Cmdx(cli.SYSTEM, cmd, "definition", m.Option(nfs.PATH)+m.Option(nfs.FILE)+nfs.DF+"#"+m.Option("offset")), nfs.DF); len(ls) > 0 {
			if strings.HasPrefix(ls[0], kit.Path("")) {
				_ls := nfs.SplitPath(m, strings.TrimPrefix(ls[0], kit.Path("")+nfs.PS))
				m.Push(nfs.PATH, _ls[0]).Push(nfs.FILE, _ls[1]).Push(nfs.LINE, ls[1])
				return
			}
		}
	}
	_c_tags(m, GOTAGS, "-f", nfs.TAGS, "-R", nfs.PWD)
}
func _go_show(m *ice.Message, arg ...string) {
	if arg[1] == MAIN_GO {
		ProcessXterm(m, kit.JoinWord("ish", arg[1]), "", "")
	} else if arg[1] == "version.go" {
		ctx.ProcessField(m, cli.RUNTIME, kit.Simple())
	} else if arg[1] == "binpack.go" {
		ctx.ProcessField(m, nfs.PACK, kit.Simple())
	} else if path.Base(arg[1]) == "model.go" {
		ctx.ProcessField(m, "web.code.mysql.query", kit.Simple("mysql", kit.Split(arg[1], "/", "/")[0]))
	} else if path.Base(arg[1]) == "common.go" {
		// ctx.ProcessField(m, "web.code.xterm", kit.Simple())
		ctx.ProcessField(m, "log.debug", kit.Simple("bench"))
	} else if cmd := ctx.GetFileCmd(path.Join(arg[2], arg[1])); cmd != "" {
		if p := path.Join(arg[2], strings.Split(arg[1], "/")[0], "portal.go"); path.Base(arg[1]) != "portal.go" && nfs.Exists(m, p) &&
			!kit.IsIn(arg[1],
				"gonganxitong/user.go",
				"gonganxitong/sess.go",
				"gonganxitong/grant.go",
				"gonganxitong/domain.go",
				"gonganxitong/command.go",
				"gonganxitong/quotalist.go",
			) {
			if cmd := ctx.GetFileCmd(p); cmd != "" {
				if m.ActionKey() == mdb.RENDER {
					ctx.ProcessField(m, cmd, kit.Simple())
				} else {
					ls := kit.Split(strings.TrimSuffix(arg[1], ".go"), "/")
					ctx.ProcessField(m, "web.code.mysql.query", kit.Simple("mysql", ls[0], TableName(kit.Select("", ls, -1))))
				}
				return
			}
		}
		ctx.ProcessField(m, cmd, kit.Simple())
	} else if msg := m.Cmd(yac.STACK, path.Join(arg[2], arg[1])); msg.Option("__index") != "" {
		ctx.ProcessField(m, msg.Option("__index"), kit.Simple())
	} else {
		ctx.ProcessField(m, yac.STACK, kit.Simple(path.Join(arg[2], arg[1])))
	}
}
func _mod_show(m *ice.Message, file string) {
	require, replace, block := ice.Maps{}, ice.Maps{}, ""
	m.Cmd(nfs.CAT, file, func(ls []string, line string) {
		switch {
		case strings.HasPrefix(line, "//"):
		case strings.HasPrefix(line, MODULE):
			require[ls[1]], replace[ls[1]] = ice.Info.Make.Versions(), nfs.PWD
		case strings.HasPrefix(line, REQUIRE+" ("):
			block = REQUIRE
		case strings.HasPrefix(line, REPLACE+" ("):
			block = REPLACE
		case strings.HasPrefix(line, ")"):
			block = ""
		case strings.HasPrefix(line, REQUIRE):
			require[ls[1]] = ls[2]
		case strings.HasPrefix(line, REPLACE):
			replace[ls[1]] = ls[3]
		default:
			kit.Switch(kit.Select("", block, len(ls) > 1), REQUIRE, func() { require[ls[0]] = ls[1] }, REPLACE, func() { replace[ls[0]] = ls[2] })
		}
	})
	kit.For(require, func(k, v string) { m.Push(REQUIRE, k).Push(VERSION, v).Push(REPLACE, kit.Select("", replace[k])) })
}
func _sum_show(m *ice.Message, file string) {
	m.Cmdy(nfs.CAT, file, func(ls []string, line string) {
		m.Push(nfs.REPOS, ls[0]).Push(nfs.VERSION, ls[1]).Push(mdb.HASH, ls[2])
	})
}

const (
	// PACKAGE = "package"
	IMPORT = "import"
	CONST  = "const"
	TYPE   = "type"
	FUNC   = "func"
	VAR    = "var"
)
const (
	MODULE  = "module"
	REQUIRE = "require"
	REPLACE = "replace"
	VERSION = "version"
	SERVICE = "service"
)
const (
	GOFMT     = "gofmt"
	GOIMPORTS = "goimports"
	GOTAGS    = "gotags"
)
const (
	GOPRIVATE   = "GOPRIVATE"
	GOPROXY     = "GOPROXY"
	GOPATH      = "GOPATH"
	GOCACHE     = "GOCACHE"
	GOMODCACHE  = "GOMODCACHE"
	CGO_ENABLED = "CGO_ENABLED"
)
const (
	ENV = "env"
	GET = "get"
	TAG = "tag"
)
const WORK = "work"
const SUM = "sum"
const MOD = "mod"
const DOC = "doc"
const GO = "go"

func init() {
	Index.MergeCommands(ice.Commands{
		GO: {Actions: ice.MergeActions(ice.Actions{
			ice.CTX_INIT: {Hand: func(m *ice.Message, arg ...string) { cli.IsRedhat(m, GO, GO); cli.IsAlpine(m, GO, GO) }},
			mdb.RENDER:   {Hand: func(m *ice.Message, arg ...string) { _go_show(m, arg...) }},
			mdb.ENGINE:   {Hand: func(m *ice.Message, arg ...string) { _go_show(m, arg...) }},
			TEMPLATE: {Hand: func(m *ice.Message, arg ...string) {
				m.Option(mdb.NAME, kit.TrimExt(path.Base(arg[1]), GO))
				m.Option(mdb.ZONE, path.Base(path.Dir(path.Join(arg[2], arg[1]))))
				m.Option(mdb.KEY, Prefix(m.Option(mdb.ZONE), m.Option(mdb.NAME)))
				m.Echo(nfs.Template(m, DEMO_GO))
			}},
			COMPLETE: {Hand: func(m *ice.Message, arg ...string) { _go_complete(m, arg...) }},
			NAVIGATE: {Hand: func(m *ice.Message, arg ...string) { _go_navigate(m, arg...) }},
			VIMER_SAVE: {Hand: func(m *ice.Message, arg ...string) {
				switch p := path.Join(m.Option(nfs.PATH), m.Option(nfs.FILE)); kit.Ext(m.Option(nfs.FILE)) {
				case nfs.GO:
					defer m.Cmdy(nfs.CAT, p)
					defer GoImports(m, p)
					defer GoFmt(m, p)
				}
			}},
		}, gdb.EventsAction(VIMER_SAVE), PlugAction())},
		DOC: {Name: "doc path name auto", Hand: func(m *ice.Message, arg ...string) {
			kit.If(strings.Contains(arg[0], nfs.PS), func() { arg[0] = kit.Path(arg[0]) })
			m.Cmdy(cli.SYSTEM, cli.GO, DOC, arg)
		}},
		WORK: {Actions: ice.MergeActions(ice.Actions{
			mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { _mod_show(m, path.Join(arg[2], arg[1])) }},
			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) { _mod_show(m, path.Join(arg[2], arg[1])) }},
		}, PlugAction())},
		MOD: {Actions: ice.MergeActions(ice.Actions{
			mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { _mod_show(m, path.Join(arg[2], arg[1])) }},
			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) { _mod_show(m, path.Join(arg[2], arg[1])) }},
		}, PlugAction())},
		SUM: {Actions: ice.MergeActions(ice.Actions{
			mdb.ENGINE: {Hand: func(m *ice.Message, arg ...string) { _sum_show(m, path.Join(arg[2], arg[1])) }},
			mdb.RENDER: {Hand: func(m *ice.Message, arg ...string) { _sum_show(m, path.Join(arg[2], arg[1])) }},
		}, PlugAction())},
	})
}
func GoEnv(m *ice.Message, k string) string { return m.Cmdx(cli.SYSTEM, GO, ENV, k) }
func GoDoc(m *ice.Message, k string) string {
	msg := m.Cmd(cli.SYSTEM, GO, DOC, k)
	return kit.Select(msg.Result(), msg.Append(cli.CMD_OUT))
}
func GoStd(m *ice.Message) string        { return m.Cmdx(cli.SYSTEM, GO, "list", "std") }
func GoGet(m *ice.Message, p string)     { m.Cmd(cli.SYSTEM, GO, GET, p) }
func GoFmt(m *ice.Message, p string)     { m.Cmd(cli.SYSTEM, GOFMT, "-w", p) }
func GoImports(m *ice.Message, p string) { m.Cmd(cli.SYSTEM, GOIMPORTS, "-w", p) }
func GoVersion(m *ice.Message) string    { return m.Cmdx(cli.SYSTEM, GO, VERSION) }
func GoBuild(m *ice.Message, target string, arg ...string) *ice.Message {
	return m.Cmdy(cli.SYSTEM, GO, cli.BUILD, "-ldflags", "-w -s", "-o", target, arg)
}
func TableName(model string) string {
	if strings.Contains("0123456789", model[len(model)-1:]) {
		return model
	}
	if kit.IsIn(model, "sms", "equipment") {

	} else if kit.HasSuffix(model, "y") {
		model = model[:len(model)-1] + "ies"
	} else if kit.HasSuffix(model, "s") {
		if !kit.HasSuffix(model, "os") {
			model = model + "es"
		}
	} else {
		model = model + "s"
	}
	return model
}