icebergs/base/yac/matrix.go

package yac

import (
	"fmt"
	"strconv"
	"strings"

	ice "github.com/shylinux/icebergs"
	"github.com/shylinux/icebergs/base/lex"
	"github.com/shylinux/icebergs/base/mdb"
	kit "github.com/shylinux/toolkits"
)

type Seed struct {
	page int
	hash int
	word []string
}
type Point struct {
	s int
	c int
}
type State struct {
	star int
	next int
	hash int
}

type Matrix struct {
	nlang int
	ncell int

	page map[string]int
	hand map[int]string
	hash map[string]int
	word map[int]string

	state map[State]*State
	mat   [][]*State

	lex     *lex.Matrix
	lex_key string
}

func NewMatrix(m *ice.Message, nlang, ncell int) *Matrix {
	mat := &Matrix{nlang: nlang, ncell: ncell}
	mat.page = map[string]int{}
	mat.hand = map[int]string{}
	mat.hash = map[string]int{}
	mat.word = map[int]string{}

	m.Option("matrix.cb", func(key string, lex *lex.Matrix) { mat.lex, mat.lex_key = lex, key })
	key := m.Cmdx("lex.matrix", mdb.CREATE, 32, 256)
	m.Cmd("lex.matrix", mdb.INSERT, key, "space", "space", "[\t \n]")

	mat.state = make(map[State]*State)
	mat.mat = make([][]*State, nlang)
	return mat
}

func (mat *Matrix) name(page int) string {
	if name, ok := mat.word[page]; ok {
		return name
	}
	return fmt.Sprintf("m%d", page)
}
func (mat *Matrix) index(m *ice.Message, hash string, h string) int {
	which, names := mat.hash, mat.word
	if hash == NPAGE {
		which, names = mat.page, mat.hand
	}

	if x, e := strconv.Atoi(h); e == nil {
		if hash == NPAGE {
			m.Assert(x <= len(mat.page))
		} else {
			mat.hash[h] = x
		}
		return x
	}

	if x, ok := which[h]; ok {
		return x
	}

	if hash == NPAGE {
		which[h] = len(mat.page) + 1
	} else {
		which[h] = len(mat.hash) + 1
	}

	names[which[h]] = h
	m.Assert(hash != NPAGE || len(mat.page) < mat.nlang)
	return which[h]
}
func (mat *Matrix) train(m *ice.Message, page, hash int, word []string, level int) (int, []*Point, []*Point) {
	m.Debug("%s %s\\%d page: %v hash: %v word: %v", TRAIN, strings.Repeat("#", level), level, page, hash, word)

	ss := []int{page}
	sn := make([]bool, len(mat.mat))
	points, ends := []*Point{}, []*Point{}

	for i, mul := 0, false; i < len(word); i++ {
		if !mul {
			if hash <= 0 && word[i] == "}" {
				return i + 2, points, ends
			}
			ends = ends[:0]
		}

		for _, s := range ss {
			switch word[i] {
			case "opt{", "rep{":
				sn[s] = true
				num, point, end := mat.train(m, s, 0, word[i+1:], level+1)
				points = append(points, point...)
				i += num - 1

				for _, x := range end {
					state := &State{}
					*state = *mat.mat[x.s][x.c]
					for i := len(sn); i <= state.next; i++ {
						sn = append(sn, false)
					}
					sn[state.next] = true

					points = append(points, x)
					if word[i] == "rep{" {
						state.star = s
						mat.mat[x.s][x.c] = state
						m.Debug("REP(%d, %d): %v", x.s, x.c, state)
					}
				}
			case "mul{":
				mul = true
				goto next
			case "}":
				if mul {
					mul = false
					goto next
				}
				fallthrough
			default:
				x, ok := mat.page[word[i]]
				if !ok {
					if x, _, _ = mat.lex.Parse(m, mat.name(s), []byte(word[i])); x == 0 {
						// x = mat.lex.Train(m, mat.name(s), fmt.Sprintf("%d", len(mat.mat[s])+1), []byte(word[i]))
						x = kit.Int(m.Cmdx("lex.matrix", mdb.INSERT, mat.lex_key, mat.name(s), len(mat.mat[s]), word[i]))
						mat.mat[s] = append(mat.mat[s], nil)
					}
				}

				c := x
				state := &State{}
				if mat.mat[s][c] != nil {
					*state = *mat.mat[s][c]
				}
				m.Debug("GET(%d,%d): %v", s, c, state)

				if state.next == 0 {
					state.next = len(mat.mat)
					mat.mat = append(mat.mat, make([]*State, mat.ncell))
					sn = append(sn, false)
				}
				sn[state.next] = true

				mat.mat[s][c] = state
				m.Debug("SET(%d,%d): %v", s, c, state)
				ends = append(ends, &Point{s, c})
				points = append(points, &Point{s, c})
			}
		}
	next:
		if !mul {
			ss = ss[:0]
			for s, b := range sn {
				if sn[s] = false; b {
					ss = append(ss, s)
				}
			}
		}
	}

	for _, s := range ss {
		if s < mat.nlang || s >= len(mat.mat) {
			continue
		}
		void := true
		for _, x := range mat.mat[s] {
			if x != nil {
				void = false
				break
			}
		}
		if void {
			mat.mat = mat.mat[:s]
			m.Debug("DEL: %d", len(mat.mat))
		}
	}

	for _, s := range ss {
		for _, p := range points {
			state := &State{}
			*state = *mat.mat[p.s][p.c]

			if state.next == s {
				m.Debug("GET(%d, %d): %v", p.s, p.c, state)
				if state.next >= len(mat.mat) {
					state.next = 0
				}
				if hash > 0 {
					state.hash = hash
				}
				mat.mat[p.s][p.c] = state
				m.Debug("SET(%d, %d): %v", p.s, p.c, state)
			}
			if x, ok := mat.state[*state]; !ok {
				mat.state[*state] = mat.mat[p.s][p.c]
			} else {
				mat.mat[p.s][p.c] = x
			}
		}
	}

	m.Debug("%s %s/%d word: %d point: %d end: %d", TRAIN, strings.Repeat("#", level), level, len(word), len(points), len(ends))
	return len(word), points, ends
}

func (mat *Matrix) Parse(m *ice.Message, rewrite Rewrite, page int, line []byte, level int) (hash int, word []string, rest []byte) {
	// m.Debug("%s %s\\%d %s(%d): %s", PARSE, strings.Repeat("#", level), level, mat.name(page), page, string(line))

	rest = line
	h, w, r := 0, []byte{}, []byte{}
	for p, i := 0, page; i > 0 && len(rest) > 0; {
		// 解析空白
		_, _, r = mat.lex.Parse(m, "space", rest)
		// 解析单词
		h, w, r = mat.lex.Parse(m, mat.name(i), r)
		// 解析状态
		s := mat.mat[i][h]

		if s != nil { // 全局语法检查
			if hh, ww, _ := mat.lex.Parse(m, "key", rest); hh == 0 || len(ww) <= len(w) {
				word, rest = append(word, string(w)), r
			} else {
				s = nil
			}
		}

		if s == nil { // 嵌套语法递归解析
			for j := 0; j < mat.ncell; j++ {
				if n := mat.mat[i][j]; j < mat.nlang && n != nil {
					if _, w, r := mat.Parse(m, rewrite, j, rest, level+1); len(r) != len(rest) {
						s, word, rest = n, append(word, w...), r
						break
					}
				}
			}
		} else {
			// m.Debug("%s %s|%d GET \033[33m%s\033[0m", PARSE, strings.Repeat("#", level), level, w)
		}

		//语法切换
		if s == nil {
			i, p = p, 0
		} else if i, p, hash = s.next, s.star, s.hash; i == 0 {
			i, p = p, 0
		}
	}

	if hash == 0 {
		word, rest = word[:0], line
	} else {
		hash, word, rest = rewrite(m, mat.hand[hash], hash, word, rest)
	}

	// m.Debug("%s %s/%d %s(%d): %v %v", PARSE, strings.Repeat("#", level), level, mat.hand[hash], hash, word, rest)
	return hash, word, rest
}
func (mat *Matrix) show(m *ice.Message) {
	max := mat.ncell
	for i := 1; i < len(mat.mat); i++ {
		if len(mat.mat[i]) > max {
			max = len(mat.mat[i])
		}
	}
	for i := 1; i < len(mat.mat); i++ {
		if len(mat.mat[i]) == 0 {
			continue
		}

		m.Push("00", kit.Select(kit.Format("%02d", i), mat.hand[i]))
		for j := 1; j < max; j++ {
			if j > len(mat.page) && j < mat.ncell {
				continue
			}
			key := kit.Select(kit.Format("w%02d", j), mat.hand[j])
			if j < len(mat.mat[i]) {
				if node := mat.mat[i][j]; node != nil {
					if node.next == 0 {
						m.Push(key, mat.word[node.hash])
					} else {
						m.Push(key, kit.Select(kit.Format("%02d", node.next), mat.hand[node.next]))
					}
					continue
				}
			}
			m.Push(key, "")
		}
	}
}

type Rewrite func(m *ice.Message, nhash string, hash int, word []string, rest []byte) (int, []string, []byte)

const (
	NLANG = "nlang"
	NCELL = "ncell"
	NSEED = "nseed"
	NPAGE = "npage"
	NHASH = "nhash"
)
const (
	TRAIN = "train"
	PARSE = "parse"
)
const MATRIX = "matrix"

func init() {
	Index.Merge(&ice.Context{
		Configs: map[string]*ice.Config{
			MATRIX: {Name: MATRIX, Help: "魔方矩阵", Value: kit.Data(kit.MDB_SHORT, kit.MDB_NAME)},
		},
		Commands: map[string]*ice.Command{
			MATRIX: {Name: "matrix name npage text auto", Help: "魔方矩阵", Action: map[string]*ice.Action{
				mdb.CREATE: {Name: "create name=shy nlang=32 ncell=32", Help: "创建", Hand: func(m *ice.Message, arg ...string) {
					mat := NewMatrix(m, kit.Int(kit.Select("32", m.Option(NLANG))), kit.Int(kit.Select("32", m.Option(NCELL))))
					h := m.Rich(m.Prefix(MATRIX), "", kit.Data(kit.MDB_TIME, m.Time(), kit.MDB_NAME, m.Option(kit.MDB_NAME), MATRIX, mat, NLANG, mat.nlang, NCELL, mat.ncell))
					switch cb := m.Optionv("matrix.cb").(type) {
					case func(string, *Matrix):
						cb(h, mat)
					}
					m.Echo(h)
				}},
				mdb.INSERT: {Name: "insert name=shy npage=num nhash=num text=123", Help: "添加", Hand: func(m *ice.Message, arg ...string) {
					m.Richs(m.Prefix(MATRIX), "", m.Option(kit.MDB_NAME), func(key string, value map[string]interface{}) {
						value = kit.GetMeta(value)

						mat, _ := value[MATRIX].(*Matrix)

						page := mat.index(m, NPAGE, m.Option(NPAGE))
						hash := mat.index(m, NHASH, m.Option(NHASH))
						if len(mat.mat[page]) == 0 {
							mat.mat[page] = make([]*State, mat.ncell)
						}

						mat.train(m, page, hash, kit.Split(m.Option(kit.MDB_TEXT)), 1)
						m.Grow(m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, key), kit.Dict(
							kit.MDB_TIME, m.Time(), NPAGE, m.Option(NPAGE), NHASH, m.Option(NHASH), kit.MDB_TEXT, m.Option(kit.MDB_TEXT),
						))

						value[NPAGE] = len(mat.page)
						value[NHASH] = len(mat.hash)
					})
				}},
				mdb.REMOVE: {Name: "create", Help: "删除", Hand: func(m *ice.Message, arg ...string) {
					m.Cmdy(mdb.DELETE, m.Prefix(MATRIX), "", mdb.HASH, kit.MDB_NAME, m.Option(kit.MDB_NAME))
				}},
				"show": {Name: "show", Help: "矩阵", Hand: func(m *ice.Message, arg ...string) {
					m.Richs(m.Prefix(MATRIX), "", m.Option(kit.MDB_NAME), func(key string, value map[string]interface{}) {
						value = kit.GetMeta(value)
						mat, _ := value[MATRIX].(*Matrix)
						mat.show(m)
					})
					m.ProcessInner()
				}},
			}, Hand: func(m *ice.Message, c *ice.Context, key string, arg ...string) {
				if m.Action(mdb.CREATE); len(arg) == 0 { // 矩阵列表
					m.Fields(len(arg) == 0, "time,name,npage,nhash")
					m.Cmdy(mdb.SELECT, m.Prefix(MATRIX), "", mdb.HASH)
					m.PushAction("show", mdb.INSERT, mdb.REMOVE)
					return
				}

				if m.Action(mdb.INSERT); len(arg) == 1 { // 词法列表
					m.Fields(len(arg) == 1, "time,npage,nhash,text")
					m.Cmdy(mdb.SELECT, m.Prefix(MATRIX), kit.Keys(kit.MDB_HASH, kit.Hashs(arg[0])), mdb.LIST)
					return
				}

				m.Richs(m.Prefix(MATRIX), "", arg[0], func(key string, value map[string]interface{}) {
					value = kit.GetMeta(value)
					mat, _ := value[MATRIX].(*Matrix)

					if len(arg) == 2 { // 词法矩阵
						mat.show(m)
						return
					}

					hash, word, rest := mat.Parse(m, func(m *ice.Message, nhash string, hash int, word []string, rest []byte) (int, []string, []byte) {
						m.Debug("\033[32mrun --- %v %v %v\033[0m", nhash, word, rest)
						return hash, word, rest
					}, mat.index(m, NPAGE, arg[1]), []byte(arg[2]), 1)

					m.Push(kit.MDB_TIME, m.Time())
					m.Push(kit.MDB_HASH, mat.word[hash])
					m.Push("word", kit.Format(word))
					m.Push("rest", string(rest))
				})
			}},
		},
	})
}