mermaid-go/pkg/parser/pie.go

// Package parser provides pie chart parsing
package parser

import (
	"fmt"
	"strconv"
	"strings"

	"mermaid-go/pkg/ast"
	"mermaid-go/pkg/lexer"
)

// PieParser implements pie chart parsing
type PieParser struct {
	tokens  []lexer.Token
	current int
	diagram *ast.PieChart
}

// NewPieParser creates a new pie parser
func NewPieParser() *PieParser {
	return &PieParser{
		diagram: &ast.PieChart{
			Data:   make([]*ast.PieSlice, 0),
			Config: make(map[string]any),
		},
	}
}

// Parse parses pie chart syntax
func (p *PieParser) Parse(input string) (*ast.PieChart, error) {
	// Tokenize
	l := lexer.NewLexer(input)
	tokens, err := l.Tokenize()
	if err != nil {
		return nil, fmt.Errorf("lexical analysis failed: %w", err)
	}

	// Filter tokens
	p.tokens = lexer.FilterTokens(tokens)
	p.current = 0
	p.diagram = &ast.PieChart{
		Data:   make([]*ast.PieSlice, 0),
		Config: make(map[string]any),
	}

	// Parse document
	err = p.parseDocument()
	if err != nil {
		return nil, fmt.Errorf("syntax analysis failed: %w", err)
	}

	return p.diagram, nil
}

// parseDocument parses the pie chart document
func (p *PieParser) parseDocument() error {
	// Expect pie
	if !p.check(lexer.TokenID) || p.peek().Value != "pie" {
		return p.error("expected 'pie'")
	}
	p.advance()

	// Check for showData option
	if p.checkKeyword("showData") {
		p.advance()
		p.diagram.Config["showData"] = true
	}

	// Parse sections
	for !p.isAtEnd() {
		if err := p.parseStatement(); err != nil {
			return err
		}
	}

	return nil
}

// parseStatement parses individual pie chart statements
func (p *PieParser) parseStatement() error {
	if p.isAtEnd() {
		return nil
	}

	switch {
	case p.check(lexer.TokenNewline):
		p.advance() // Skip newlines
		return nil
	case p.checkKeyword("title"):
		return p.parseTitle()
	case p.check(lexer.TokenString):
		return p.parseSlice()
	default:
		// Try to parse as label without quotes
		if p.check(lexer.TokenID) {
			return p.parseSliceWithoutQuotes()
		}
		token := p.peek()
		return p.error(fmt.Sprintf("unexpected token: %s", token.Value))
	}
}

// parseTitle parses title statements
func (p *PieParser) parseTitle() error {
	p.advance() // consume 'title'

	var titleParts []string
	for !p.check(lexer.TokenNewline) && !p.isAtEnd() {
		titleParts = append(titleParts, p.advance().Value)
	}

	if len(titleParts) > 0 {
		title := strings.TrimSpace(strings.Join(titleParts, " "))
		p.diagram.Title = &title
	}

	return nil
}

// parseSlice parses a pie slice with quoted label
func (p *PieParser) parseSlice() error {
	// Parse label
	label := p.advance().Value

	// Remove quotes
	if strings.HasPrefix(label, "\"") && strings.HasSuffix(label, "\"") {
		label = label[1 : len(label)-1]
	}

	// Expect colon
	if !p.check(lexer.TokenColon) {
		return p.error("expected ':' after pie slice label")
	}
	p.advance()

	// Parse value
	if !p.check(lexer.TokenID) && !p.check(lexer.TokenNumber) {
		return p.error("expected numeric value after ':'")
	}

	valueStr := p.advance().Value
	value, err := strconv.ParseFloat(valueStr, 64)
	if err != nil {
		return p.error(fmt.Sprintf("invalid numeric value: %s", valueStr))
	}

	// Validate non-negative value
	if value < 0 {
		return p.error(fmt.Sprintf("negative values not allowed in pie charts: %f", value))
	}

	slice := &ast.PieSlice{
		Label: label,
		Value: value,
	}

	p.diagram.Data = append(p.diagram.Data, slice)
	return nil
}

// parseSliceWithoutQuotes parses a pie slice with unquoted label
func (p *PieParser) parseSliceWithoutQuotes() error {
	// Parse label (single word)
	label := p.advance().Value

	// Expect colon
	if !p.check(lexer.TokenColon) {
		return p.error("expected ':' after pie slice label")
	}
	p.advance()

	// Parse value
	if !p.check(lexer.TokenID) && !p.check(lexer.TokenNumber) {
		return p.error("expected numeric value after ':'")
	}

	valueStr := p.advance().Value
	value, err := strconv.ParseFloat(valueStr, 64)
	if err != nil {
		return p.error(fmt.Sprintf("invalid numeric value: %s", valueStr))
	}

	// Validate non-negative value
	if value < 0 {
		return p.error(fmt.Sprintf("negative values not allowed in pie charts: %f", value))
	}

	slice := &ast.PieSlice{
		Label: label,
		Value: value,
	}

	p.diagram.Data = append(p.diagram.Data, slice)
	return nil
}

// Helper methods
func (p *PieParser) check(tokenType lexer.TokenType) bool {
	if p.isAtEnd() {
		return false
	}
	return p.peek().Type == tokenType
}

func (p *PieParser) checkKeyword(keyword string) bool {
	if p.isAtEnd() {
		return false
	}
	token := p.peek()
	return token.Type == lexer.TokenID && strings.ToLower(token.Value) == strings.ToLower(keyword)
}

func (p *PieParser) advance() lexer.Token {
	if !p.isAtEnd() {
		p.current++
	}
	return p.previous()
}

func (p *PieParser) isAtEnd() bool {
	return p.current >= len(p.tokens) || p.peek().Type == lexer.TokenEOF
}

func (p *PieParser) peek() lexer.Token {
	if p.current >= len(p.tokens) {
		return lexer.Token{Type: lexer.TokenEOF}
	}
	return p.tokens[p.current]
}

func (p *PieParser) previous() lexer.Token {
	if p.current <= 0 {
		return lexer.Token{Type: lexer.TokenEOF}
	}
	return p.tokens[p.current-1]
}

func (p *PieParser) error(message string) error {
	token := p.peek()
	return fmt.Errorf("parse error at line %d, column %d: %s (got %s)",
		token.Line, token.Column, message, token.Type.String())
}