package circuitcompiler

import (
	"errors"
	"io"
)

type Parser struct {
	s   *Scanner
	buf struct {
		tok Token  // last read token
		lit string // last read literal
		n   int    // buffer size (max=1)
	}
}

type Constraint struct {
	// v1 op v2 = out
	Op      Token
	V1      Token
	V2      Token
	Out     Token
	Literal string
}

func NewParser(r io.Reader) *Parser {
	return &Parser{s: NewScanner(r)}
}

func (p *Parser) scan() (tok Token, lit string) {
	// if there is a token in the buffer return it
	if p.buf.n != 0 {
		p.buf.n = 0
		return p.buf.tok, p.buf.lit
	}
	tok, lit = p.s.Scan()

	p.buf.tok, p.buf.lit = tok, lit

	return
}

func (p *Parser) unscan() {
	p.buf.n = 1
}

func (p *Parser) scanIgnoreWhitespace() (tok Token, lit string) {
	tok, lit = p.scan()
	if tok == WS {
		tok, lit = p.scan()
	}
	return
}

func (p *Parser) ParseLine() (*Constraint, error) {
	/*
		in this version,
		line will be for example s3 = s1 * s4
		this is:
		val op val op val
		ident op ident op ident
	*/
	c := &Constraint{}
	var lit string
	c.Out, lit = p.scanIgnoreWhitespace()
	c.Literal += lit
	_, lit = p.scanIgnoreWhitespace() // skip =
	c.Literal += lit
	c.V1, lit = p.scanIgnoreWhitespace()
	c.Literal += lit
	c.Op, lit = p.scanIgnoreWhitespace()
	c.Literal += lit
	c.V2, lit = p.scanIgnoreWhitespace()
	c.Literal += lit
	if c.Out == EOF {
		return nil, errors.New("eof in parseline")
	}
	return c, nil
}

func (p *Parser) Parse() (*Circuit, error) {
	circuit := &Circuit{}
	for {
		constraint, err := p.ParseLine()
		if err != nil {
			// return circuit, err
			break
		}
		circuit.Constraints = append(circuit.Constraints, *constraint)
	}
	return circuit, nil
}