package main

import (
	"encoding/xml"
	"fmt"
	"os"
	"sort"
	"strings"
	"time"

	"github.com/pebbe/util"
	"github.com/rug-compling/alpinods"
)

var (
	x      = util.CheckErr
	noNode = &NodeType{
		NodeAttributes: alpinods.NodeAttributes{
			Begin: -1,
			End:   -1,
			ID:    -1,
		},
		Node:                []*NodeType{},
		AxParent:            []interface{}{},
		AxAncestors:         []interface{}{},
		AxAncestorsOrSelf:   []interface{}{},
		AxChildren:          []interface{}{},
		AxDescendants:       []interface{}{},
		AxDescendantsOrSelf: []interface{}{},
	}
)

func main() {
	b, err := os.ReadFile(os.Args[1])
	x(err)

	var alpino Alpino_ds
	x(xml.Unmarshal(b, &alpino))

	// Extra node bovenaan vanwege gedoe met //node
	// Wordt weer verwijderd in alpinoRestore()
	alpino.Node = &NodeType{
		NodeAttributes: alpinods.NodeAttributes{
			Begin: alpino.Node.Begin,
			End:   alpino.Node.End,
			ID:    -2, // ??? TODO
		},
		Node: []*NodeType{alpino.Node},
	}

	var walk func(*NodeType)
	walk = func(node *NodeType) {
		if node.Node == nil {
			node.Node = make([]*NodeType, 0)
		} else {
			for _, n := range node.Node {
				walk(n)
			}
		}
	}
	walk(alpino.Node)

	qq := &Context{
		Alpino:   &alpino,
		Sentence: alpino.Sentence.Sent,
		Sentid:   alpino.Sentence.SentId,
		Varroot:  []interface{}{alpino.Node},
	}

	inspect(qq)

	now := time.Now()
	for i := 0; i < 100000; i++ {
		_, err := query.Do(qq)
		x(err)
	}
	fmt.Println(time.Since(now))
	/*
		for _, m := range mm {
			fmt.Println(m.(*NodeType).NodeAttributes.ID)
		}
	*/
}

func inspect(q *Context) {
	allnodes := make([]*NodeType, 0)
	varallnodes := make([]interface{}, 0)
	ptnodes := make([]*NodeType, 0)
	varindexnodes := make([]interface{}, 0)

	indextable := make(map[int]*NodeType)

	var walk func(*NodeType)
	walk = func(node *NodeType) {
		if node.Index > 0 && (node.Word != "" || len(node.Node) > 0) {
			indextable[node.Index] = node
		}

		// bug in Alpino: missing pt
		if node.Word != "" && node.Pt == "" {
			node.Pt = strings.ToLower(strings.Split(node.Postag, "(")[0])
			if node.Pt == "" {
				node.Pt = "na"
			}
		}

		allnodes = append(allnodes, node)
		varallnodes = append(varallnodes, node)
		if node.Pt != "" {
			ptnodes = append(ptnodes, node)
		}
		if node.Index > 0 {
			varindexnodes = append(varindexnodes, node)
		}
		for _, n := range node.Node {
			n.Parent = node
			n.AxParent = []interface{}{node}
			walk(n)
		}
		node.AxChildren = make([]interface{}, 0)
		node.AxDescendants = make([]interface{}, 0)
		node.AxDescendantsOrSelf = make([]interface{}, 1)
		node.AxDescendantsOrSelf[0] = node
		for _, n := range node.Node {
			node.AxChildren = append(node.AxChildren, n)
			node.AxDescendants = append(node.AxDescendants, n)
			node.AxDescendants = append(node.AxDescendants, n.AxDescendants...)
			node.AxDescendantsOrSelf = append(node.AxDescendantsOrSelf, n.AxDescendantsOrSelf...) // niet n
		}
	}
	walk(q.Alpino.Node)
	q.Alpino.Node.Parent = noNode
	q.Alpino.Node.AxParent = []interface{}{}

	var found map[int]bool
	walk = func(node *NodeType) {
		if node.Index > 0 {
			node = indextable[node.Index]
		}
		if node.Word != "" {
			found[node.ID] = true
		} else {
			for _, n := range node.Node {
				walk(n)
			}
		}
	}
	for _, node := range allnodes {
		found = make(map[int]bool)
		walk(node)
		node.NodeSize = len(found)
	}

	for _, node := range allnodes {
		node.AxAncestors = make([]interface{}, 0)
		node.AxAncestorsOrSelf = make([]interface{}, 0)
		node.AxAncestorsOrSelf = append(node.AxAncestorsOrSelf, node)
		if node != q.Alpino.Node {
			node.AxAncestors = append(node.AxAncestors, node.Parent)
			node.AxAncestors = append(node.AxAncestors, node.Parent.AxAncestors...)
			if node.AxAncestors[len(node.AxAncestors)-1] != q.Alpino.Node {
				// zou niet mogelijk moeten zijn
				panic("Missing ancestors in " + q.Filename)
			}
			node.AxAncestorsOrSelf = append(node.AxAncestorsOrSelf, node.Parent.AxAncestorsOrSelf...)
		}
	}

	sort.Slice(ptnodes, func(i, j int) bool {
		return ptnodes[i].End < ptnodes[j].End
	})
	varptnodes := make([]interface{}, len(ptnodes))
	for i, node := range ptnodes {
		varptnodes[i] = node
	}

	q.Allnodes = allnodes
	q.Varallnodes = varallnodes
	q.Varindexnodes = varindexnodes
	q.Ptnodes = ptnodes
	q.Varptnodes = varptnodes
}