// package syntax -- синтаксический потоковый анализатор
//
//	Читает по одно литере и пытается определеить символ
package syntax

import (
	"fmt"
	"log"
	"unicode"
)

const ( // Класс литеры
	alpha   = "alpha" // Буква
	digit   = "digit" // Цифра
	space   = "space" // Пробел
	dot     = "dot"   // Точка
	newLine = "\n"    // Новая строка
)

// Syntax -- синтаксический потоковый анализатор
type Syntax struct {
	runeSrc []rune // Исходный набор рун для анализа
}

// NewSyntax -- возвращает новый потоовый синтаксический анализатор
func NewSyntax(runeSrc []rune) (*Syntax, error) {
	log.Printf("NewSyntax()\n")
	if runeSrc == nil {
		return nil, fmt.Errorf("NewSyntax(): runeSrc==nil")
	}
	sf := &Syntax{
		runeSrc: runeSrc,
	}
	return sf, nil
}

// Run -- обрабатыает входящий поток данных
func (sf *Syntax) Run() error {
	log.Printf("Syntax.Run()\n")
	i := 0
	for {
		if len(sf.runeSrc) == 0 {
			break
		}
		_rune := sf.runeSrc[0]
		// что за тип руны?
		switch class := sf.classifyRune(_rune); class {
		case alpha: // какая-то буква, проверить наличие 'модуль'
			sf.checkModuleBegin()
		case digit:
			// fmt.Printf("класс = цифра\n")
		case space:
		case dot:
		case newLine:
		default:
			strRune := string(_rune)
			fmt.Printf("%v\trune = %v\t", i, strRune)
			fmt.Printf("класс = неизвестный\n")
		}
		i++
	}
	return fmt.Errorf("Syntax.Run(): доделать")
}

// Пытается вычислить начало модуля
func (sf *Syntax)checkModuleBegin()bool{
	
}
// Классифицирует очередную руну из текста
func (sf *Syntax) classifyRune(rune_ rune) string {
	if unicode.IsLetter(rune_) {
		return alpha
	}
	if unicode.IsDigit(rune_) {
		return digit
	}
	return ""
}