package unstable

import (

	"bytes"

	"fmt"

	"unicode"

	"github.com/pelletier/go-toml/v2/internal/characters"

	"github.com/pelletier/go-toml/v2/internal/danger"

)

// ParserError describes an error relative to the content of the document.

//

// It cannot outlive the instance of Parser it refers to, and may cause panics

// if the parser is reset.

type ParserError struct {

	Highlight []byte

	Message   string

	Key       []string // optional

}

// Error is the implementation of the error interface.

func (e *ParserError) Error() string {

	return e.Message

}

// NewParserError is a convenience function to create a ParserError

//

// Warning: Highlight needs to be a subslice of Parser.data, so only slices

// returned by Parser.Raw are valid candidates.

func NewParserError(highlight []byte, format string, args ...interface{}) error {

	return &ParserError{

		Highlight: highlight,

		Message:   fmt.Errorf(format, args...).Error(),

	}

}

// Parser scans over a TOML-encoded document and generates an iterative AST.

//

// To prime the Parser, first reset it with the contents of a TOML document.

// Then, process all top-level expressions sequentially. See Example.

//

// Don't forget to check Error() after you're done parsing.

//

// Each top-level expression needs to be fully processed before calling

// NextExpression() again. Otherwise, calls to various Node methods may panic if

// the parser has moved on the next expression.

//

// For performance reasons, go-toml doesn't make a copy of the input bytes to

// the parser. Make sure to copy all the bytes you need to outlive the slice

// given to the parser.

//

// The parser doesn't provide nodes for comments yet, nor for whitespace.

type Parser struct {

	data    []byte

	builder builder

	ref     reference

	left    []byte

	err     error

	first   bool

}

// Data returns the slice provided to the last call to Reset.

func (p *Parser) Data() []byte {

	return p.data

}

// Range returns a range description that corresponds to a given slice of the

// input. If the argument is not a subslice of the parser input, this function

// panics.

func (p *Parser) Range(b []byte) Range {

	return Range{

		Offset: uint32(danger.SubsliceOffset(p.data, b)),

		Length: uint32(len(b)),

	}

}

// Raw returns the slice corresponding to the bytes in the given range.

func (p *Parser) Raw(raw Range) []byte {

	return p.data[raw.Offset : raw.Offset+raw.Length]

}

// Reset brings the parser to its initial state for a given input. It wipes an

// reuses internal storage to reduce allocation.

func (p *Parser) Reset(b []byte) {

	p.builder.Reset()

	p.ref = invalidReference

	p.data = b

	p.left = b

	p.err = nil

	p.first = true

}

// NextExpression parses the next top-level expression. If an expression was

// successfully parsed, it returns true. If the parser is at the end of the

// document or an error occurred, it returns false.

//

// Retrieve the parsed expression with Expression().

func (p *Parser) NextExpression() bool {

	if len(p.left) == 0 || p.err != nil {

		return false

	}

	p.builder.Reset()

	p.ref = invalidReference

	for {

		if len(p.left) == 0 || p.err != nil {

			return false

		}

		if !p.first {

			p.left, p.err = p.parseNewline(p.left)

		}

		if len(p.left) == 0 || p.err != nil {

			return false

		}

		p.ref, p.left, p.err = p.parseExpression(p.left)

		if p.err != nil {

			return false

		}

		p.first = false

		if p.ref.Valid() {

			return true

		}

	}

}

// Expression returns a pointer to the node representing the last successfully

// parsed expresion.

func (p *Parser) Expression() *Node {

	return p.builder.NodeAt(p.ref)

}

// Error returns any error that has occured during parsing.

func (p *Parser) Error() error {

	return p.err

}

func (p *Parser) parseNewline(b []byte) ([]byte, error) {

	if b[0] == '\n' {

		return b[1:], nil

	}

	if b[0] == '\r' {

		_, rest, err := scanWindowsNewline(b)

		return rest, err

	}

	return nil, NewParserError(b[0:1], "expected newline but got %#U", b[0])

}

func (p *Parser) parseExpression(b []byte) (reference, []byte, error) {

	// expression =  ws [ comment ]

	// expression =/ ws keyval ws [ comment ]

	// expression =/ ws table ws [ comment ]

	ref := invalidReference

	b = p.parseWhitespace(b)

	if len(b) == 0 {

		return ref, b, nil

	}

	if b[0] == '#' {

		_, rest, err := scanComment(b)

		return ref, rest, err

	}

	if b[0] == '\n' || b[0] == '\r' {

		return ref, b, nil

	}

	var err error

	if b[0] == '[' {

		ref, b, err = p.parseTable(b)

	} else {

		ref, b, err = p.parseKeyval(b)

	}

	if err != nil {

		return ref, nil, err

	}

	b = p.parseWhitespace(b)

	if len(b) > 0 && b[0] == '#' {

		_, rest, err := scanComment(b)

		return ref, rest, err

	}

	return ref, b, nil

}

func (p *Parser) parseTable(b []byte) (reference, []byte, error) {

	// table = std-table / array-table

	if len(b) > 1 && b[1] == '[' {

		return p.parseArrayTable(b)

	}

	return p.parseStdTable(b)

}

func (p *Parser) parseArrayTable(b []byte) (reference, []byte, error) {

	// array-table = array-table-open key array-table-close

	// array-table-open  = %x5B.5B ws  ; [[ Double left square bracket

	// array-table-close = ws %x5D.5D  ; ]] Double right square bracket

	ref := p.builder.Push(Node{

		Kind: ArrayTable,

	})

	b = b[2:]

	b = p.parseWhitespace(b)

	k, b, err := p.parseKey(b)

	if err != nil {

		return ref, nil, err

	}

	p.builder.AttachChild(ref, k)

	b = p.parseWhitespace(b)

	b, err = expect(']', b)

	if err != nil {

		return ref, nil, err

	}

	b, err = expect(']', b)

	return ref, b, err

}

func (p *Parser) parseStdTable(b []byte) (reference, []byte, error) {

	// std-table = std-table-open key std-table-close

	// std-table-open  = %x5B ws     ; [ Left square bracket

	// std-table-close = ws %x5D     ; ] Right square bracket

	ref := p.builder.Push(Node{

		Kind: Table,

	})

	b = b[1:]

	b = p.parseWhitespace(b)

	key, b, err := p.parseKey(b)

	if err != nil {

		return ref, nil, err

	}

	p.builder.AttachChild(ref, key)

	b = p.parseWhitespace(b)

	b, err = expect(']', b)

	return ref, b, err

}

func (p *Parser) parseKeyval(b []byte) (reference, []byte, error) {

	// keyval = key keyval-sep val

	ref := p.builder.Push(Node{

		Kind: KeyValue,

	})

	key, b, err := p.parseKey(b)

	if err != nil {

		return invalidReference, nil, err

	}

	// keyval-sep = ws %x3D ws ; =

	b = p.parseWhitespace(b)

	if len(b) == 0 {

		return invalidReference, nil, NewParserError(b, "expected = after a key, but the document ends there")

	}

	b, err = expect('=', b)

	if err != nil {

		return invalidReference, nil, err

	}

	b = p.parseWhitespace(b)

	valRef, b, err := p.parseVal(b)

	if err != nil {

		return ref, b, err

	}

	p.builder.Chain(valRef, key)

	p.builder.AttachChild(ref, valRef)

	return ref, b, err

}

//nolint:cyclop,funlen

func (p *Parser) parseVal(b []byte) (reference, []byte, error) {

	// val = string / boolean / array / inline-table / date-time / float / integer

	ref := invalidReference

	if len(b) == 0 {

		return ref, nil, NewParserError(b, "expected value, not eof")

	}

	var err error

	c := b[0]

	switch c {

	case '"':

		var raw []byte

		var v []byte

		if scanFollowsMultilineBasicStringDelimiter(b) {

			raw, v, b, err = p.parseMultilineBasicString(b)

		} else {

			raw, v, b, err = p.parseBasicString(b)

		}

		if err == nil {

			ref = p.builder.Push(Node{

				Kind: String,

				Raw:  p.Range(raw),

				Data: v,

			})

		}

		return ref, b, err

	case '\'':

		var raw []byte

		var v []byte

		if scanFollowsMultilineLiteralStringDelimiter(b) {

			raw, v, b, err = p.parseMultilineLiteralString(b)

		} else {

			raw, v, b, err = p.parseLiteralString(b)

		}

		if err == nil {

			ref = p.builder.Push(Node{

				Kind: String,

				Raw:  p.Range(raw),

				Data: v,

			})

		}

		return ref, b, err

	case 't':

		if !scanFollowsTrue(b) {

			return ref, nil, NewParserError(atmost(b, 4), "expected 'true'")

		}

		ref = p.builder.Push(Node{

			Kind: Bool,

			Data: b[:4],

		})

		return ref, b[4:], nil

	case 'f':

		if !scanFollowsFalse(b) {

			return ref, nil, NewParserError(atmost(b, 5), "expected 'false'")

		}

		ref = p.builder.Push(Node{

			Kind: Bool,

			Data: b[:5],

		})

		return ref, b[5:], nil

	case '[':

		return p.parseValArray(b)

	case '{':

		return p.parseInlineTable(b)

	default:

		return p.parseIntOrFloatOrDateTime(b)

	}

}

func atmost(b []byte, n int) []byte {

	if n >= len(b) {

		return b

	}

	return b[:n]

}

func (p *Parser) parseLiteralString(b []byte) ([]byte, []byte, []byte, error) {

	v, rest, err := scanLiteralString(b)

	if err != nil {

		return nil, nil, nil, err

	}

	return v, v[1 : len(v)-1], rest, nil

}

func (p *Parser) parseInlineTable(b []byte) (reference, []byte, error) {

	// inline-table = inline-table-open [ inline-table-keyvals ] inline-table-close

	// inline-table-open  = %x7B ws     ; {

	// inline-table-close = ws %x7D     ; }

	// inline-table-sep   = ws %x2C ws  ; , Comma

	// inline-table-keyvals = keyval [ inline-table-sep inline-table-keyvals ]

	parent := p.builder.Push(Node{