package query

import (
	"context"
	"github.com/glennliao/apijson-go/config"
	"github.com/glennliao/apijson-go/config/db"
	"github.com/glennliao/apijson-go/config/executor"
	"github.com/glennliao/apijson-go/config/functions"
	"github.com/glennliao/apijson-go/consts"
	"github.com/glennliao/apijson-go/util"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/samber/lo"
	"path/filepath"
	"strings"
	"time"
)

const (
	NodeTypeStruct = iota // 结构节点
	NodeTypeQuery         // 查询节点
	NodeTypeRef           // 引用节点
	NodeTypeFunc          // functions 节点
)

type Node struct {
	ctx          context.Context
	queryContext *Query

	// 当前节点key Todos
	Key string
	// 当前节点path -> []/Todos
	Path string
	// 节点类型
	Type int

	// 是否为列表节点
	isList bool
	page   g.Map // 分页参数

	// 访问当前节点的角色
	role string

	// 节点的请求数据
	req          g.Map
	simpleReqVal string //非对象结构

	// 节点数据执行器
	executor executor.QueryExecutor

	startAt time.Time
	endAt   time.Time

	// 执行完毕
	finish bool

	ret any
	err error

	children map[string]*Node

	refKeyMap map[string]NodeRef // 关联字段

	primaryTableKey string // 主查询表

	total     int64 // 数据总条数
	needTotal bool
}

// NodeRef 节点依赖引用
type NodeRef struct {
	column string
	node   *Node
}

/**
node 生命周期
new -> buildChild -> parse -> fetch -> result
*/

func newNode(query *Query, key string, path string, nodeReq any) *Node {

	if query.PrintProcessLog {
		g.Log().Debugf(query.ctx, "【node】(%s) <new> ", path)
	}

	node := &Node{
		ctx:          query.ctx,
		queryContext: query,
		Key:          key,
		Path:         path,
		startAt:      time.Now(),
		finish:       false,
	}

	// 节点类型判断
	if key != "" {

		k, isList := util.ParseNodeKey(key)

		if util.IsFirstUp(k) { // 大写开头, 为查询节点(对应数据库)
			node.Type = NodeTypeQuery
		} else if strings.HasSuffix(k, consts.RefKeySuffix) {
			node.Type = NodeTypeRef
		} else if strings.HasSuffix(k, consts.FunctionsKeySuffix) {
			node.Type = NodeTypeFunc
		} else {
			node.Type = NodeTypeStruct // 结构节点下应该必须存在查询节点

			if !query.AccessVerify {
				if lo.Contains(db.GetTableNameList(), k) {
					node.Type = NodeTypeQuery
				}
			}
		}

		if isList || strings.HasSuffix(filepath.Dir(path), consts.ListKeySuffix) {
			node.isList = true
		}
	}

	if req, ok := nodeReq.(g.Map); ok {
		node.req = req

	} else {
		node.simpleReqVal = gconv.String(nodeReq)
	}

	return node
}

func (n *Node) buildChild() error {

	if n.Type == NodeTypeQuery && !util.HasFirstUpKey(n.req) { // 查询节点嵌套查询节点, 目前不支持
		return nil
	}

	// 最大深度检查
	if len(strings.Split(n.Path, "/")) > config.MaxTreeDeep {
		return gerror.Newf("deep(%s) > %d", n.Path, config.MaxTreeDeep)
	}

	children := make(map[string]*Node)

	for key, v := range n.req {

		if strings.HasPrefix(key, consts.RefKeySuffix) {
			continue
		}

		if n.Type == NodeTypeQuery && !util.IsFirstUp(key) { // 查询节点嵌套查询节点, 目前不支持
			continue
		}

		if n.isList {
			if lo.Contains([]string{"total", "page"}, key) {
				continue
			}
		}

		path := n.Path
		if path != "" { // 根节点时不带/
			path += "/"
		}
		node := newNode(n.queryContext, key, path+key, v)

		if n.Type != NodeTypeQuery { // 非查询节点role主要的功能是传递角色(设置该节点下子节点的角色)
			setNodeRole(node, "", n.role)
		}

		err := node.buildChild()
		if err != nil {
			return err
		}
		children[key] = node
	}

	if len(children) > 0 {

		// 最大宽度检查, 目前为某节点的宽度, 应该计算为整棵树的最大宽度
		if len(children) > config.MaxTreeWidth {
			path := n.Path
			if path == "" {
				path = "root"
			}
			return gerror.Newf("width(%s) > %d", path, config.MaxTreeWidth)
		}

		n.children = children

		for _, node := range children {
			n.queryContext.pathNodes[node.Path] = node
		}
	}

	return nil
}

func (n *Node) parse() {

	if n.queryContext.PrintProcessLog {
		g.Log().Debugf(n.ctx, "【node】(%s) <parse> ", n.Path)
	}

	switch n.Type {
	case NodeTypeQuery:
		tableKey := parseTableKey(n.Key, n.Path)

		access, err := db.GetAccess(tableKey, n.queryContext.AccessVerify)
		if err != nil {
			n.err = err
			return
		}

		var accessWhereCondition g.Map

		setNodeRole(n, access.Name, n.role)

		if n.role == consts.DENY {
			n.err = gerror.New("deny node: " + n.Path)
			return
		}

		if n.queryContext.AccessVerify {
			has, condition, err := hasAccess(n, tableKey)
			if err != nil {
				n.err = err
				return
			}

			if !has {
				n.err = gerror.New("无权限访问:" + tableKey + " by " + n.role)
				return
			}

			accessWhereCondition = condition
		}

		queryExecutor, err := executor.NewQueryExecutor(access.Executor, n.ctx, n.queryContext.AccessVerify, n.role, access)
		if err != nil {
			n.err = err
			return
		}

		n.executor = queryExecutor

		// 查询条件
		refKeyMap, conditionMap, ctrlMap := parseQueryNodeReq(n.req, n.isList)

		n.executor.ParseCtrl(ctrlMap)

		err = n.executor.ParseCondition(conditionMap, true)
		if err != nil {
			n.err = err
			return
		}

		err = n.executor.ParseCondition(accessWhereCondition, false)
		if err != nil {
			n.err = err
			return
		}

		n.primaryTableKey = n.Key

		if len(refKeyMap) > 0 { // 需要引用别处
			n.refKeyMap = make(map[string]NodeRef)
			hasRefBrother := false // 是否引用兄弟节点, 列表中的主表不能依赖兄弟节点

			for refKey, refStr := range refKeyMap {
				if strings.HasPrefix(refStr, "/") { // 这里/开头是相对同级
					refStr = filepath.Dir(n.Path) + refStr
				}

				refPath, refCol := util.ParseRefCol(refStr)

				if !hasRefBrother {
					if filepath.Dir(n.Path) == filepath.Dir(refPath) {
						hasRefBrother = true
					}
				}

				if refPath == n.Path { // 不能依赖自身
					n.err = gerror.Newf("node cannot ref self: (%s) {%s:%s}", refPath, refKey, refStr)
					return
				}

				refNode := n.queryContext.pathNodes[refPath]
				if refNode == nil {
					n.err = gerror.Newf(" node %s is nil, but ref by %s", refPath, n.Path)
					return
				}

				if refNode.err != nil {
					n.err = refNode.err
					return
				}

				for _, _refN := range refNode.refKeyMap {
					if _refN.node.Path == n.Path {
						n.err = gerror.Newf("circle ref %s & %s", refNode.Path, n.Path)
						return
					}
				}

				n.refKeyMap[refKey] = NodeRef{
					column: refCol,
					node:   refNode,
				}

			}

			if hasRefBrother {
				n.primaryTableKey = ""
			}
		}

	case NodeTypeRef:

		refStr := n.simpleReqVal
		if strings.HasPrefix(refStr, "/") { // 这里/开头是相对同级
			refStr = filepath.Dir(n.Path) + refStr
		}
		refPath, refCol := util.ParseRefCol(refStr)
		if refPath == n.Path { // 不能依赖自身
			panic(gerror.Newf("node cannot ref self: (%s)", refPath))
		}

		refNode := n.queryContext.pathNodes[refPath]
		if refNode == nil {
			panic(gerror.Newf(" node %s is nil, but ref by %s", refPath, n.Path))
		}

		n.refKeyMap = make(map[string]NodeRef)

		if strings.HasSuffix(n.simpleReqVal, "[]/total") {
			setNeedTotal(refNode)
		}

		n.refKeyMap[n.Key] = NodeRef{
			column: refCol,
			node:   refNode,
		}

	case NodeTypeStruct:

		for _, childNode := range n.children {
			childNode.parse()
		}

		if n.isList { // []节点

			page := g.Map{}
			if v, exists := n.req[consts.Page]; exists {
				page[consts.Page] = gconv.Int(v)
			}
			if v, exists := n.req[consts.Count]; exists {
				page[consts.Count] = gconv.Int(v)
			}

			hasPrimary := false // 是否存在主查询表
			for _, child := range n.children {

				if child.err != nil {
					n.err = child.err
					return
				}

				if child.primaryTableKey != "" {

					if hasPrimary {
						panic(gerror.Newf("node must only one primary table: (%s)", n.Path))
					}

					hasPrimary = true
					n.primaryTableKey = child.Key
					child.page = page

				}
			}

			if n.Key == consts.ListKeySuffix && !hasPrimary {
				panic(gerror.Newf("node must have  primary table: (%s)", n.Path))
			}
		}

	case NodeTypeFunc:
		functionName, _ := util.ParseFunctionsStr(n.simpleReqVal)
		n.simpleReqVal = functionName

	}
	if n.queryContext.PrintProcessLog {
		g.Log().Debugf(n.ctx, "【node】(%s) <parse-endAt> ", n.Path)
	}

}

func (n *Node) fetch() {

	defer func() {
		n.finish = true
		n.endAt = time.Now()
		if n.queryContext.PrintProcessLog {
			g.Log().Debugf(n.ctx, "【node】(%s) <fetch-endAt> ", n.Path)
		}
	}()

	if n.queryContext.PrintProcessLog {
		g.Log().Debugf(n.ctx, "【node】(%s) <fetch> hasFinish: 【%v】", n.Path, n.finish)
	}

	if n.finish {
		g.Log().Error(n.ctx, "再次执行", n.Path)
		return
	}

	if n.err != nil {
		return
	}

	switch n.Type {
	case NodeTypeQuery:

		for refK, refNode := range n.refKeyMap {
			ret, err := refNode.node.Result()
			if err != nil {
				n.err = err
				return
			}

			if refNode.node.isList {
				list := ret.([]g.Map)

				valList := getColList(list, refNode.column)
				if len(valList) == 0 { // 未查询到主表, 故当前不再查询
					n.executor.EmptyResult()
					break
				}

				err = n.executor.ParseCondition(g.Map{
					refK + "{}": valList, //  @ 与 {}&等的结合 id{}@的处理
				}, false)

				if err != nil {
					n.err = err
					return
				}

			} else {

				if ret == nil { // 未查询到主表, 故当前不再查询
					n.executor.EmptyResult()
					break
				}

				item := ret.(g.Map)

				refVal := item[refNode.column]

				var refConditionMap = g.Map{
					refK: refVal,
				}
				err = n.executor.ParseCondition(refConditionMap, false)
				if err != nil {
					n.err = err
					return
				}
			}
		}

		if n.isList {

			page := 1
			count := 10

			for k, v := range n.page {
				switch k {
				case consts.Page:
					page = gconv.Int(v)

				case consts.Count:
					count = gconv.Int(v)
				}
			}

			for k, v := range n.req {
				switch k {
				case consts.Page:
					page = gconv.Int(v)

				case consts.Count:
					count = gconv.Int(v)
				case consts.Query:
					switch gconv.String(v) {
					case "1", "2":
						n.needTotal = true
					}
				}
			}

			if n.primaryTableKey == "" { // 主查询表 才分页
				page = 0
				count = 0
			}

			n.ret, n.total, n.err = n.executor.List(page, count, n.needTotal)
		} else {
			n.ret, n.err = n.executor.One()
		}
		if n.err != nil {
			return
		}

		// 需优化调整
		for k, v := range n.req {
			if !strings.HasSuffix(k, consts.FunctionsKeySuffix) {
				continue
			}

			k = k[0 : len(k)-2]

			functionName, paramKeys := util.ParseFunctionsStr(v.(string))

			if n.isList {
				for i, item := range n.ret.([]g.Map) {
					var param = g.Map{}
					for _, key := range paramKeys {
						if key == consts.FunctionOriReqParam {
							param[key] = item
						} else {
							param[key] = item[key]
						}
					}
					var err error
					n.ret.([]g.Map)[i][k], err = functions.Call(n.ctx, functionName, param)
					if err != nil {
						panic(err)
					}
				}
			} else {
				var param = g.Map{}
				for _, key := range paramKeys {
					if key == consts.FunctionOriReqParam {
						param[key] = n.ret.(g.Map)
					} else {
						param[key] = n.ret.(g.Map)[key]
					}

				}
				var err error
				n.ret.(g.Map)[k], err = functions.Call(n.ctx, functionName, param)
				if err != nil {
					panic(err)
				}
			}
		}

	case NodeTypeRef:
		for _, refNode := range n.refKeyMap {
			if strings.HasSuffix(refNode.column, "total") && strings.HasSuffix(refNode.node.Path, consts.ListKeySuffix) {
				n.total = refNode.node.total
			}
		}

	case NodeTypeStruct:
		// 目前结构节点组装数据在result, 如果被依赖的是组装后的, 则无法查询。 如遇到此情况再看
		if n.isList && n.needTotal {
			n.total = n.children[n.primaryTableKey].total
		}
	case NodeTypeFunc:
		param := g.Map{}
		n.ret, n.err = functions.Call(n.ctx, n.simpleReqVal, param)
	}

}

func (n *Node) Result() (any, error) {

	if n.err != nil {
		return nil, n.err
	}

	switch n.Type {
	case NodeTypeQuery:
		if n.isList {
			if n.ret == nil || n.ret.([]g.Map) == nil {
				return []g.Map{}, n.err
			}
		} else {
			if n.ret == nil || n.ret.(g.Map) == nil {
				return nil, n.err
			}
		}

	case NodeTypeRef:
		if strings.HasSuffix(n.simpleReqVal, "[]/total") {
			return n.total, nil
		}
	case NodeTypeStruct:
		if n.isList {
			var retList []g.Map

			var primaryList []g.Map

			if n.children[n.primaryTableKey].ret != nil {
				primaryList = n.children[n.primaryTableKey].ret.([]g.Map)

				for i := 0; i < len(primaryList); i++ {

					pItem := primaryList[i]

					item := g.Map{
						n.primaryTableKey: pItem,
					}

					// 遍历组装数据, 后续考虑使用别的方案优化 (暂未简单使用map的id->item ,主要考虑多字段问题)
					for childK, childNode := range n.children {
						if childNode.primaryTableKey == "" {
							if childNode.ret != nil {

								var resultList []g.Map

								for _, depRetItem := range childNode.ret.([]g.Map) {
									match := true
									for refK, refNode := range childNode.refKeyMap {
										if pItem[refNode.column] != depRetItem[refK] {
											match = false
											break
										}
									}
									if match {
										resultList = append(resultList, depRetItem)
									}

								}
								if len(resultList) > 0 {
									if strings.HasSuffix(childK, consts.ListKeySuffix) {
										item[childK] = resultList
									} else {
										item[childK] = resultList[0]
									}
								}

							}

						}
					}

					retList = append(retList, item)
				}
			}

			n.ret = retList
		} else {

			retMap := g.Map{}
			for k, node := range n.children {
				var err error
				if strings.HasSuffix(k, consts.RefKeySuffix) {
					k = k[0 : len(k)-1]
				}
				if strings.HasSuffix(k, consts.FunctionsKeySuffix) {
					k = k[0 : len(k)-2]
				}

				retMap[k], err = node.Result()
				if node.Type == NodeTypeFunc && retMap[k] == nil {
					delete(retMap, k)
				}

				if err != nil {
					return nil, err
				}
			}
			n.ret = retMap
		}

	}

	return n.ret, n.err

}