package syntax

import (
	"io"
	"os"
	"runtime"
	"git.smesh.lol/moxie/pkg/token"
)

type Mode uint32

const (
	CheckBranches Mode = 1 << iota
)

type Error struct {
	Pos token.Pos
	Msg string
}

func (err *Error) Error() (s string) {
	return err.Pos.String() | ": " | err.Msg
}

func (err *Error) String() (s string) { return err.Error() }

var CompileExportMap map[string]string

type ErrorHandler func(err error)

type Pragma interface{}

type PragmaHandler func(pos token.Pos, blank bool, text string, current Pragma) Pragma

func Parse(base *token.PosBase, src io.Reader, errh ErrorHandler, pragh PragmaHandler, mode Mode) (_ *File, first error) {
	defer func() {
		if rv := recover(); rv != nil {
			if err, ok := rv.(*Error); ok {
				first = err
				return
			}
			panic(rv)
		}
	}()

	var p Parser
	p.init(base, src, errh, pragh, mode)
	p.Next()
	return p.fileOrNil(), p.First
}

func ParseBytes(base *token.PosBase, src []byte, errh ErrorHandler, pragh PragmaHandler, mode Mode) (_ *File, first error) {
	return ParseBytesArena(base, src, errh, pragh, mode, nil)
}

func ParseBytesArena(base *token.PosBase, src []byte, errh ErrorHandler, pragh PragmaHandler, mode Mode, arena *runtime.Arena) (_ *File, first error) {
	var p Parser
	p.Arena = arena
	p.initBytes(base, src, errh, pragh, mode)
	return parseWithRecover(&p)
}

func parseWithRecover(p *Parser) (_ *File, first error) {
	defer func() {
		if rv := recover(); rv != nil {
			if err, ok := rv.(*Error); ok {
				first = err
				return
			}
			panic(rv)
		}
	}()

	p.Next()
	return p.fileOrNil(), p.First
}

func ParseFile(filename string, errh ErrorHandler, pragh PragmaHandler, mode Mode) (_ *File, err error) {
	f, err := os.Open(filename)
	if err != nil {
		if errh != nil {
			errh(err)
		}
		return nil, err
	}
	defer f.Close()
	return Parse(token.NewFileBase(filename), f, errh, pragh, mode)
}