Claude Code transcript - page 2/7

package main

import (
	"flag"
	"fmt"
	"os"
)

const version = "0.1.0"

func main() {
	showVersion := flag.Bool("version", false, "Print version and exit")
	outputFile := flag.String("o", "", "Output file (default: stdout)")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "occam2go - An Occam to Go transpiler\n\n")
		fmt.Fprintf(os.Stderr, "Usage: %s [options] <input.occ>\n\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "Options:\n")
		flag.PrintDefaults()
	}

	flag.Parse()

	if *showVersion {
		fmt.Printf("occam2go version %s\n", version)
		os.Exit(0)
	}

	args := flag.Args()
	if len(args) < 1 {
		flag.Usage()
		os.Exit(1)
	}

	inputFile := args[0]

	// TODO: Implement transpiler
	fmt.Printf("Input file: %s\n", inputFile)
	if *outputFile != "" {
		fmt.Printf("Output file: %s\n", *outputFile)
	}
	fmt.Println("Transpiler not yet implemented")
}

package lexer

type TokenType int

const (
	// Special tokens
	ILLEGAL TokenType = iota
	EOF
	NEWLINE
	INDENT
	DEDENT

	// Literals
	IDENT  // variable names, procedure names
	INT    // integer literal
	STRING // string literal

	// Operators
	ASSIGN   // :=
	PLUS     // +
	MINUS    // -
	MULTIPLY // *
	DIVIDE   // /
	MODULO   // \ (backslash in Occam)
	EQ       // =
	NEQ      // <>
	LT       // <
	GT       // >
	LE       // <=
	GE       // >=
	SEND     // !
	RECEIVE  // ?

	// Delimiters
	LPAREN    // (
	RPAREN    // )
	LBRACKET  // [
	RBRACKET  // ]
	COMMA     // ,
	COLON     // :
	SEMICOLON // ;

	// Keywords
	keyword_beg
	SEQ
	PAR
	ALT
	IF
	WHILE
	FOR
	PROC
	FUNC
	CHAN
	OF
	TRUE
	FALSE
	NOT
	AND
	OR
	SKIP
	STOP
	INT_TYPE
	BYTE_TYPE
	BOOL_TYPE
	REAL_TYPE
	VAL
	keyword_end
)

var tokenNames = map[TokenType]string{
	ILLEGAL: "ILLEGAL",
	EOF:     "EOF",
	NEWLINE: "NEWLINE",
	INDENT:  "INDENT",
	DEDENT:  "DEDENT",

	IDENT:  "IDENT",
	INT:    "INT",
	STRING: "STRING",

	ASSIGN:   ":=",
	PLUS:     "+",
	MINUS:    "-",
	MULTIPLY: "*",
	DIVIDE:   "/",
	MODULO:   "\\",
	EQ:       "=",
	NEQ:      "<>",
	LT:       "<",
	GT:       ">",
	LE:       "<=",
	GE:       ">=",
	SEND:     "!",
	RECEIVE:  "?",

	LPAREN:    "(",
	RPAREN:    ")",
	LBRACKET:  "[",
	RBRACKET:  "]",
	COMMA:     ",",
	COLON:     ":",
	SEMICOLON: ";",

	SEQ:       "SEQ",
	PAR:       "PAR",
	ALT:       "ALT",
	IF:        "IF",
	WHILE:     "WHILE",
	FOR:       "FOR",
	PROC:      "PROC",
	FUNC:      "FUNC",
	CHAN:      "CHAN",
	OF:        "OF",
	TRUE:      "TRUE",
	FALSE:     "FALSE",
	NOT:       "NOT",
	AND:       "AND",
	OR:        "OR",
	SKIP:      "SKIP",
	STOP:      "STOP",
	INT_TYPE:  "INT",
	BYTE_TYPE: "BYTE",
	BOOL_TYPE: "BOOL",
	REAL_TYPE: "REAL",
	VAL:       "VAL",
}

var keywords = map[string]TokenType{
	"SEQ":   SEQ,
	"PAR":   PAR,
	"ALT":   ALT,
	"IF":    IF,
	"WHILE": WHILE,
	"FOR":   FOR,
	"PROC":  PROC,
	"FUNC":  FUNC,
	"CHAN":  CHAN,
	"OF":    OF,
	"TRUE":  TRUE,
	"FALSE": FALSE,
	"NOT":   NOT,
	"AND":   AND,
	"OR":    OR,
	"SKIP":  SKIP,
	"STOP":  STOP,
	"INT":   INT_TYPE,
	"BYTE":  BYTE_TYPE,
	"BOOL":  BOOL_TYPE,
	"REAL":  REAL_TYPE,
	"VAL":   VAL,
}

func (t TokenType) String() string {
	if name, ok := tokenNames[t]; ok {
		return name
	}
	return "UNKNOWN"
}

func LookupIdent(ident string) TokenType {
	if tok, ok := keywords[ident]; ok {
		return tok
	}
	return IDENT
}

type Token struct {
	Type    TokenType
	Literal string
	Line    int
	Column  int
}

package lexer

import (
	"strings"
)

type Lexer struct {
	input        string
	position     int  // current position in input (points to current char)
	readPosition int  // current reading position (after current char)
	ch           byte // current char under examination
	line         int
	column       int

	// Indentation tracking
	indentStack  []int // stack of indentation levels
	pendingTokens []Token // tokens to emit before reading more input
	atLineStart  bool
}

func New(input string) *Lexer {
	l := &Lexer{
		input:       input,
		line:        1,
		column:      0,
		indentStack: []int{0}, // start with base indentation of 0
		atLineStart: true,
	}
	l.readChar()
	return l
}

func (l *Lexer) readChar() {
	if l.readPosition >= len(l.input) {
		l.ch = 0
	} else {
		l.ch = l.input[l.readPosition]
	}
	l.position = l.readPosition
	l.readPosition++
	l.column++
}

func (l *Lexer) peekChar() byte {
	if l.readPosition >= len(l.input) {
		return 0
	}
	return l.input[l.readPosition]
}

func (l *Lexer) NextToken() Token {
	// Return any pending tokens first (from indentation processing)
	if len(l.pendingTokens) > 0 {
		tok := l.pendingTokens[0]
		l.pendingTokens = l.pendingTokens[1:]
		return tok
	}

	// Handle indentation at the start of a line
	if l.atLineStart {
		l.atLineStart = false
		indent := l.measureIndent()
		currentIndent := l.indentStack[len(l.indentStack)-1]

		if indent > currentIndent {
			l.indentStack = append(l.indentStack, indent)
			return Token{Type: INDENT, Literal: "", Line: l.line, Column: 1}
		} else if indent < currentIndent {
			// May need multiple DEDENTs
			for len(l.indentStack) > 1 && l.indentStack[len(l.indentStack)-1] > indent {
				l.indentStack = l.indentStack[:len(l.indentStack)-1]
				l.pendingTokens = append(l.pendingTokens, Token{Type: DEDENT, Literal: "", Line: l.line, Column: 1})
			}
			if len(l.pendingTokens) > 0 {
				tok := l.pendingTokens[0]
				l.pendingTokens = l.pendingTokens[1:]
				return tok
			}
		}
	}

	l.skipWhitespace()

	var tok Token
	tok.Line = l.line
	tok.Column = l.column

	switch l.ch {
	case '(':
		tok = l.newToken(LPAREN, l.ch)
	case ')':
		tok = l.newToken(RPAREN, l.ch)
	case '[':
		tok = l.newToken(LBRACKET, l.ch)
	case ']':
		tok = l.newToken(RBRACKET, l.ch)
	case ',':
		tok = l.newToken(COMMA, l.ch)
	case ';':
		tok = l.newToken(SEMICOLON, l.ch)
	case '+':
		tok = l.newToken(PLUS, l.ch)
	case '*':
		tok = l.newToken(MULTIPLY, l.ch)
	case '/':
		tok = l.newToken(DIVIDE, l.ch)
	case '\\':
		tok = l.newToken(MODULO, l.ch)
	case '=':
		tok = l.newToken(EQ, l.ch)
	case '!':
		tok = l.newToken(SEND, l.ch)
	case '?':
		tok = l.newToken(RECEIVE, l.ch)
	case ':':
		if l.peekChar() == '=' {
			ch := l.ch
			l.readChar()
			tok = Token{Type: ASSIGN, Literal: string(ch) + string(l.ch), Line: l.line, Column: l.column - 1}
		} else {
			tok = l.newToken(COLON, l.ch)
		}
	case '<':
		if l.peekChar() == '=' {
			ch := l.ch
			l.readChar()
			tok = Token{Type: LE, Literal: string(ch) + string(l.ch), Line: l.line, Column: l.column - 1}
		} else if l.peekChar() == '>' {
			ch := l.ch
			l.readChar()
			tok = Token{Type: NEQ, Literal: string(ch) + string(l.ch), Line: l.line, Column: l.column - 1}
		} else {
			tok = l.newToken(LT, l.ch)
		}
	case '>':
		if l.peekChar() == '=' {
			ch := l.ch
			l.readChar()
			tok = Token{Type: GE, Literal: string(ch) + string(l.ch), Line: l.line, Column: l.column - 1}
		} else {
			tok = l.newToken(GT, l.ch)
		}
	case '-':
		if l.peekChar() == '-' {
			l.skipComment()
			return l.NextToken()
		} else {
			tok = l.newToken(MINUS, l.ch)
		}
	case '"':
		tok.Type = STRING
		tok.Literal = l.readString()
	case '\n':
		tok = Token{Type: NEWLINE, Literal: "\\n", Line: l.line, Column: l.column}
		l.line++
		l.column = 0
		l.atLineStart = true
		l.readChar()
		// Skip blank lines
		for l.ch == '\n' || (l.atLineStart && l.isBlankLine()) {
			if l.ch == '\n' {
				l.line++
				l.column = 0
				l.readChar()
			} else {
				l.skipToEndOfLine()
			}
		}
		return tok
	case 0:
		// Emit any remaining DEDENTs before EOF
		if len(l.indentStack) > 1 {
			l.indentStack = l.indentStack[:len(l.indentStack)-1]
			return Token{Type: DEDENT, Literal: "", Line: l.line, Column: l.column}
		}
		tok.Literal = ""
		tok.Type = EOF
	default:
		if isLetter(l.ch) {
			tok.Literal = l.readIdentifier()
			tok.Type = LookupIdent(tok.Literal)
			tok.Line = l.line
			return tok
		} else if isDigit(l.ch) {
			tok.Type = INT
			tok.Literal = l.readNumber()
			tok.Line = l.line
			return tok
		} else {
			tok = l.newToken(ILLEGAL, l.ch)
		}
	}

	l.readChar()
	return tok
}

func (l *Lexer) newToken(tokenType TokenType, ch byte) Token {
	return Token{Type: tokenType, Literal: string(ch), Line: l.line, Column: l.column}
}

func (l *Lexer) readIdentifier() string {
	position := l.position
	for isLetter(l.ch) || isDigit(l.ch) || l.ch == '.' {
		l.readChar()
	}
	return l.input[position:l.position]
}

func (l *Lexer) readNumber() string {
	position := l.position
	for isDigit(l.ch) {
		l.readChar()
	}
	return l.input[position:l.position]
}

func (l *Lexer) readString() string {
	position := l.position + 1
	for {
		l.readChar()
		if l.ch == '"' || l.ch == 0 {
			break
		}
	}
	return l.input[position:l.position]
}

func (l *Lexer) skipWhitespace() {
	for l.ch == ' ' || l.ch == '\t' || l.ch == '\r' {
		l.readChar()
	}
}

func (l *Lexer) skipComment() {
	// Skip -- comment until end of line
	for l.ch != '\n' && l.ch != 0 {
		l.readChar()
	}
}

func (l *Lexer) measureIndent() int {
	indent := 0
	pos := l.position
	for pos < len(l.input) {
		ch := l.input[pos]
		if ch == ' ' {
			indent++
			pos++
		} else if ch == '\t' {
			indent += 2 // treat tabs as 2 spaces
			pos++
		} else {
			break
		}
	}
	return indent
}

func (l *Lexer) isBlankLine() bool {
	pos := l.position
	for pos < len(l.input) {
		ch := l.input[pos]
		if ch == '\n' {
			return true
		}
		if ch != ' ' && ch != '\t' && ch != '\r' {
			// Check for comment-only line
			if ch == '-' && pos+1 < len(l.input) && l.input[pos+1] == '-' {
				return true
			}
			return false
		}
		pos++
	}
	return true // end of file counts as blank
}

func (l *Lexer) skipToEndOfLine() {
	for l.ch != '\n' && l.ch != 0 {
		l.readChar()
	}
	if l.ch == '\n' {
		l.line++
		l.column = 0
		l.readChar()
	}
}

func isLetter(ch byte) bool {
	return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_'
}

func isDigit(ch byte) bool {
	return ch >= '0' && ch <= '9'
}

// Tokenize returns all tokens from the input
func Tokenize(input string) []Token {
	// Ensure input ends with newline for consistent processing
	if !strings.HasSuffix(input, "\n") {
		input = input + "\n"
	}

	l := New(input)
	var tokens []Token
	for {
		tok := l.NextToken()
		tokens = append(tokens, tok)
		if tok.Type == EOF {
			break
		}
	}
	return tokens
}

package lexer

import (
	"testing"
)

func TestBasicTokens(t *testing.T) {
	input := `INT x:
x := 5
`
	tests := []struct {
		expectedType    TokenType
		expectedLiteral string
	}{
		{INT_TYPE, "INT"},
		{IDENT, "x"},
		{COLON, ":"},
		{NEWLINE, "\\n"},
		{IDENT, "x"},
		{ASSIGN, ":="},
		{INT, "5"},
		{NEWLINE, "\\n"},
		{EOF, ""},
	}

	l := New(input)
	for i, tt := range tests {
		tok := l.NextToken()
		if tok.Type != tt.expectedType {
			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q (literal=%q)",
				i, tt.expectedType, tok.Type, tok.Literal)
		}
		if tok.Literal != tt.expectedLiteral {
			t.Fatalf("tests[%d] - literal wrong. expected=%q, got=%q",
				i, tt.expectedLiteral, tok.Literal)
		}
	}
}

func TestIndentation(t *testing.T) {
	input := `SEQ
  INT x:
  x := 10
`
	tests := []struct {
		expectedType    TokenType
		expectedLiteral string
	}{
		{SEQ, "SEQ"},
		{NEWLINE, "\\n"},
		{INDENT, ""},
		{INT_TYPE, "INT"},
		{IDENT, "x"},
		{COLON, ":"},
		{NEWLINE, "\\n"},
		{IDENT, "x"},
		{ASSIGN, ":="},
		{INT, "10"},
		{NEWLINE, "\\n"},
		{DEDENT, ""},
		{EOF, ""},
	}

	l := New(input)
	for i, tt := range tests {
		tok := l.NextToken()
		if tok.Type != tt.expectedType {
			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q (literal=%q)",
				i, tt.expectedType, tok.Type, tok.Literal)
		}
	}
}

func TestOperators(t *testing.T) {
	input := `x + y - z * a / b
x < y
x > y
x <= y
x >= y
x = y
x <> y
`
	l := New(input)

	expected := []TokenType{
		IDENT, PLUS, IDENT, MINUS, IDENT, MULTIPLY, IDENT, DIVIDE, IDENT, NEWLINE,
		IDENT, LT, IDENT, NEWLINE,
		IDENT, GT, IDENT, NEWLINE,
		IDENT, LE, IDENT, NEWLINE,
		IDENT, GE, IDENT, NEWLINE,
		IDENT, EQ, IDENT, NEWLINE,
		IDENT, NEQ, IDENT, NEWLINE,
		EOF,
	}

	for i, exp := range expected {
		tok := l.NextToken()
		if tok.Type != exp {
			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q",
				i, exp, tok.Type)
		}
	}
}

func TestKeywords(t *testing.T) {
	input := `SEQ PAR ALT IF WHILE PROC INT BYTE BOOL TRUE FALSE`
	expected := []TokenType{
		SEQ, PAR, ALT, IF, WHILE, PROC, INT_TYPE, BYTE_TYPE, BOOL_TYPE, TRUE, FALSE,
		NEWLINE, EOF,
	}

	l := New(input)
	for i, exp := range expected {
		tok := l.NextToken()
		if tok.Type != exp {
			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q (literal=%q)",
				i, exp, tok.Type, tok.Literal)
		}
	}
}

func TestComments(t *testing.T) {
	input := `INT x: -- this is a comment
x := 5
`
	tests := []struct {
		expectedType    TokenType
		expectedLiteral string
	}{
		{INT_TYPE, "INT"},
		{IDENT, "x"},
		{COLON, ":"},
		{NEWLINE, "\\n"},
		{IDENT, "x"},
		{ASSIGN, ":="},
		{INT, "5"},
		{NEWLINE, "\\n"},
		{EOF, ""},
	}

	l := New(input)
	for i, tt := range tests {
		tok := l.NextToken()
		if tok.Type != tt.expectedType {
			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q",
				i, tt.expectedType, tok.Type)
		}
	}
}

func TestNestedIndentation(t *testing.T) {
	input := `SEQ
  INT x:
  PAR
    x := 1
    x := 2
  x := 3
`
	expected := []TokenType{
		SEQ, NEWLINE,
		INDENT, INT_TYPE, IDENT, COLON, NEWLINE,
		PAR, NEWLINE,
		INDENT, IDENT, ASSIGN, INT, NEWLINE,
		IDENT, ASSIGN, INT, NEWLINE,
		DEDENT, IDENT, ASSIGN, INT, NEWLINE,
		DEDENT, EOF,
	}

	l := New(input)
	for i, exp := range expected {
		tok := l.NextToken()
		if tok.Type != exp {
			t.Fatalf("tests[%d] - tokentype wrong. expected=%q, got=%q (literal=%q)",
				i, exp, tok.Type, tok.Literal)
		}
	}
}

package ast

import (
	"github.com/codeassociates/occam2go/lexer"
)

// Node is the base interface for all AST nodes
type Node interface {
	TokenLiteral() string
}

// Statement represents a statement node
type Statement interface {
	Node
	statementNode()
}

// Expression represents an expression node
type Expression interface {
	Node
	expressionNode()
}

// Program is the root node of every AST
type Program struct {
	Statements []Statement
}

func (p *Program) TokenLiteral() string {
	if len(p.Statements) > 0 {
		return p.Statements[0].TokenLiteral()
	}
	return ""
}

// VarDecl represents a variable declaration: INT x:
type VarDecl struct {
	Token lexer.Token // the type token (INT, BYTE, BOOL)
	Type  string      // "INT", "BYTE", "BOOL", etc.
	Names []string    // variable names (can declare multiple: INT x, y, z:)
}

func (v *VarDecl) statementNode()       {}
func (v *VarDecl) TokenLiteral() string { return v.Token.Literal }

// Assignment represents an assignment: x := 5
type Assignment struct {
	Token lexer.Token // the := token
	Name  string      // variable name
	Value Expression  // the value being assigned
}

func (a *Assignment) statementNode()       {}
func (a *Assignment) TokenLiteral() string { return a.Token.Literal }

// SeqBlock represents a SEQ block (sequential execution)
type SeqBlock struct {
	Token      lexer.Token // the SEQ token
	Statements []Statement
}

func (s *SeqBlock) statementNode()       {}
func (s *SeqBlock) TokenLiteral() string { return s.Token.Literal }

// ParBlock represents a PAR block (parallel execution)
type ParBlock struct {
	Token      lexer.Token // the PAR token
	Statements []Statement
}

func (p *ParBlock) statementNode()       {}
func (p *ParBlock) TokenLiteral() string { return p.Token.Literal }

// Skip represents the SKIP statement (no-op)
type Skip struct {
	Token lexer.Token
}

func (s *Skip) statementNode()       {}
func (s *Skip) TokenLiteral() string { return s.Token.Literal }

// ProcDecl represents a procedure declaration
type ProcDecl struct {
	Token  lexer.Token // the PROC token
	Name   string
	Params []ProcParam
	Body   Statement // usually a SEQ block
}

func (p *ProcDecl) statementNode()       {}
func (p *ProcDecl) TokenLiteral() string { return p.Token.Literal }

// ProcParam represents a procedure parameter
type ProcParam struct {
	IsVal bool   // VAL parameter (pass by value)
	Type  string // INT, BYTE, BOOL, etc.
	Name  string
}

// ProcCall represents a procedure call
type ProcCall struct {
	Token lexer.Token // the procedure name token
	Name  string
	Args  []Expression
}

func (p *ProcCall) statementNode()       {}
func (p *ProcCall) TokenLiteral() string { return p.Token.Literal }

// WhileLoop represents a WHILE loop
type WhileLoop struct {
	Token     lexer.Token // the WHILE token
	Condition Expression
	Body      Statement
}

func (w *WhileLoop) statementNode()       {}
func (w *WhileLoop) TokenLiteral() string { return w.Token.Literal }

// IfStatement represents an IF statement
type IfStatement struct {
	Token   lexer.Token // the IF token
	Choices []IfChoice
}

type IfChoice struct {
	Condition Expression
	Body      Statement
}

func (i *IfStatement) statementNode()       {}
func (i *IfStatement) TokenLiteral() string { return i.Token.Literal }

// Expressions

// Identifier represents a variable reference
type Identifier struct {
	Token lexer.Token
	Value string
}

func (i *Identifier) expressionNode()      {}
func (i *Identifier) TokenLiteral() string { return i.Token.Literal }

// IntegerLiteral represents an integer literal
type IntegerLiteral struct {
	Token lexer.Token
	Value int64
}

func (il *IntegerLiteral) expressionNode()      {}
func (il *IntegerLiteral) TokenLiteral() string { return il.Token.Literal }

// BooleanLiteral represents TRUE or FALSE
type BooleanLiteral struct {
	Token lexer.Token
	Value bool
}

func (bl *BooleanLiteral) expressionNode()      {}
func (bl *BooleanLiteral) TokenLiteral() string { return bl.Token.Literal }

// BinaryExpr represents a binary operation: x + y
type BinaryExpr struct {
	Token    lexer.Token // the operator token
	Left     Expression
	Operator string
	Right    Expression
}

func (be *BinaryExpr) expressionNode()      {}
func (be *BinaryExpr) TokenLiteral() string { return be.Token.Literal }

// UnaryExpr represents a unary operation: NOT x, -x
type UnaryExpr struct {
	Token    lexer.Token // the operator token
	Operator string
	Right    Expression
}

func (ue *UnaryExpr) expressionNode()      {}
func (ue *UnaryExpr) TokenLiteral() string { return ue.Token.Literal }

// ParenExpr represents a parenthesized expression
type ParenExpr struct {
	Token lexer.Token
	Expr  Expression
}

func (pe *ParenExpr) expressionNode()      {}
func (pe *ParenExpr) TokenLiteral() string { return pe.Token.Literal }

package parser

import (
	"fmt"
	"strconv"

	"github.com/codeassociates/occam2go/ast"
	"github.com/codeassociates/occam2go/lexer"
)

// Operator precedence levels
const (
	_ int = iota
	LOWEST
	OR_PREC      // OR
	AND_PREC     // AND
	EQUALS       // =, <>
	LESSGREATER  // <, >, <=, >=
	SUM          // +, -
	PRODUCT      // *, /, \
	PREFIX       // -x, NOT x
)

var precedences = map[lexer.TokenType]int{
	lexer.OR:       OR_PREC,
	lexer.AND:      AND_PREC,
	lexer.EQ:       EQUALS,
	lexer.NEQ:      EQUALS,
	lexer.LT:       LESSGREATER,
	lexer.GT:       LESSGREATER,
	lexer.LE:       LESSGREATER,
	lexer.GE:       LESSGREATER,
	lexer.PLUS:     SUM,
	lexer.MINUS:    SUM,
	lexer.MULTIPLY: PRODUCT,
	lexer.DIVIDE:   PRODUCT,
	lexer.MODULO:   PRODUCT,
}

type Parser struct {
	l      *lexer.Lexer
	errors []string

	curToken  lexer.Token
	peekToken lexer.Token

	// Track current indentation level
	indentLevel int
}

func New(l *lexer.Lexer) *Parser {
	p := &Parser{
		l:      l,
		errors: []string{},
	}
	// Read two tokens to initialize curToken and peekToken
	p.nextToken()
	p.nextToken()
	return p
}

func (p *Parser) Errors() []string {
	return p.errors
}

func (p *Parser) addError(msg string) {
	p.errors = append(p.errors, fmt.Sprintf("line %d: %s", p.curToken.Line, msg))
}

func (p *Parser) nextToken() {
	p.curToken = p.peekToken
	p.peekToken = p.l.NextToken()

	// Track indentation level
	if p.curToken.Type == lexer.INDENT {
		p.indentLevel++
	} else if p.curToken.Type == lexer.DEDENT {
		p.indentLevel--
	}
}

func (p *Parser) curTokenIs(t lexer.TokenType) bool {
	return p.curToken.Type == t
}

func (p *Parser) peekTokenIs(t lexer.TokenType) bool {
	return p.peekToken.Type == t
}

func (p *Parser) expectPeek(t lexer.TokenType) bool {
	if p.peekTokenIs(t) {
		p.nextToken()
		return true
	}
	p.addError(fmt.Sprintf("expected %s, got %s", t, p.peekToken.Type))
	return false
}

func (p *Parser) peekPrecedence() int {
	if prec, ok := precedences[p.peekToken.Type]; ok {
		return prec
	}
	return LOWEST
}

func (p *Parser) curPrecedence() int {
	if prec, ok := precedences[p.curToken.Type]; ok {
		return prec
	}
	return LOWEST
}

// ParseProgram parses the entire program
func (p *Parser) ParseProgram() *ast.Program {
	program := &ast.Program{}
	program.Statements = []ast.Statement{}

	for !p.curTokenIs(lexer.EOF) {
		stmt := p.parseStatement()
		if stmt != nil {
			program.Statements = append(program.Statements, stmt)
		}
		p.nextToken()
	}

	return program
}

func (p *Parser) parseStatement() ast.Statement {
	// Skip newlines
	for p.curTokenIs(lexer.NEWLINE) {
		p.nextToken()
	}

	switch p.curToken.Type {
	case lexer.INT_TYPE, lexer.BYTE_TYPE, lexer.BOOL_TYPE, lexer.REAL_TYPE:
		return p.parseVarDecl()
	case lexer.SEQ:
		return p.parseSeqBlock()
	case lexer.PAR:
		return p.parseParBlock()
	case lexer.SKIP:
		return &ast.Skip{Token: p.curToken}
	case lexer.PROC:
		return p.parseProcDecl()
	case lexer.WHILE:
		return p.parseWhileLoop()
	case lexer.IF:
		return p.parseIfStatement()
	case lexer.IDENT:
		// Could be assignment or procedure call
		if p.peekTokenIs(lexer.ASSIGN) {
			return p.parseAssignment()
		}
		return p.parseProcCall()
	case lexer.INDENT, lexer.DEDENT, lexer.EOF:
		return nil
	default:
		p.addError(fmt.Sprintf("unexpected token: %s", p.curToken.Type))
		return nil
	}
}

func (p *Parser) parseVarDecl() *ast.VarDecl {
	decl := &ast.VarDecl{
		Token: p.curToken,
		Type:  p.curToken.Literal,
	}

	// Parse variable names
	for {
		if !p.expectPeek(lexer.IDENT) {
			return nil
		}
		decl.Names = append(decl.Names, p.curToken.Literal)

		if p.peekTokenIs(lexer.COMMA) {
			p.nextToken() // consume comma
		} else {
			break
		}
	}

	if !p.expectPeek(lexer.COLON) {
		return nil
	}

	return decl
}

func (p *Parser) parseAssignment() *ast.Assignment {
	stmt := &ast.Assignment{
		Name: p.curToken.Literal,
	}

	p.nextToken() // move to :=
	stmt.Token = p.curToken

	p.nextToken() // move past :=
	stmt.Value = p.parseExpression(LOWEST)

	return stmt
}

func (p *Parser) parseSeqBlock() *ast.SeqBlock {
	block := &ast.SeqBlock{Token: p.curToken}

	// Skip to next line
	for p.peekTokenIs(lexer.NEWLINE) {
		p.nextToken()
	}

	// Expect INDENT
	if !p.peekTokenIs(lexer.INDENT) {
		p.addError("expected indented block after SEQ")
		return block
	}
	p.nextToken() // consume INDENT

	block.Statements = p.parseBlockStatements()

	return block
}

func (p *Parser) parseParBlock() *ast.ParBlock {
	block := &ast.ParBlock{Token: p.curToken}

	// Skip to next line
	for p.peekTokenIs(lexer.NEWLINE) {
		p.nextToken()
	}

	// Expect INDENT
	if !p.peekTokenIs(lexer.INDENT) {
		p.addError("expected indented block after PAR")
		return block
	}
	p.nextToken() // consume INDENT

	block.Statements = p.parseBlockStatements()

	return block
}

func (p *Parser) parseBlockStatements() []ast.Statement {
	var statements []ast.Statement
	startLevel := p.indentLevel

	p.nextToken() // move past INDENT

	for !p.curTokenIs(lexer.EOF) && !p.curTokenIs(lexer.DEDENT) {
		// Stop if we've dedented to original level
		if p.indentLevel < startLevel {
			break
		}

		stmt := p.parseStatement()
		if stmt != nil {
			statements = append(statements, stmt)
		}
		p.nextToken()
	}

	return statements
}

func (p *Parser) parseProcDecl() *ast.ProcDecl {
	proc := &ast.ProcDecl{Token: p.curToken}

	if !p.expectPeek(lexer.IDENT) {
		return nil
	}
	proc.Name = p.curToken.Literal

	if !p.expectPeek(lexer.LPAREN) {
		return nil
	}

	proc.Params = p.parseProcParams()

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	// Skip to next line and expect indented body
	for p.peekTokenIs(lexer.NEWLINE) {
		p.nextToken()
	}

	if !p.peekTokenIs(lexer.INDENT) {
		p.addError("expected indented body after PROC declaration")
		return proc
	}
	p.nextToken() // consume INDENT

	// Parse the procedure body (first statement in the indented block)
	p.nextToken()
	proc.Body = p.parseStatement()

	// Consume remaining statements at this level and the DEDENT
	for !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
		p.nextToken()
	}

	return proc
}

func (p *Parser) parseProcParams() []ast.ProcParam {
	var params []ast.ProcParam

	if p.peekTokenIs(lexer.RPAREN) {
		return params
	}

	p.nextToken()

	for {
		param := ast.ProcParam{}

		// Check for VAL keyword
		if p.curTokenIs(lexer.VAL) {
			param.IsVal = true
			p.nextToken()
		}

		// Expect type
		if !p.curTokenIs(lexer.INT_TYPE) && !p.curTokenIs(lexer.BYTE_TYPE) &&
			!p.curTokenIs(lexer.BOOL_TYPE) && !p.curTokenIs(lexer.REAL_TYPE) {
			p.addError(fmt.Sprintf("expected type in parameter, got %s", p.curToken.Type))
			return params
		}
		param.Type = p.curToken.Literal
		p.nextToken()

		// Expect identifier
		if !p.curTokenIs(lexer.IDENT) {
			p.addError(fmt.Sprintf("expected parameter name, got %s", p.curToken.Type))
			return params
		}
		param.Name = p.curToken.Literal

		params = append(params, param)

		if !p.peekTokenIs(lexer.COMMA) {
			break
		}
		p.nextToken() // consume comma
		p.nextToken() // move to next param
	}

	return params
}

func (p *Parser) parseProcCall() *ast.ProcCall {
	call := &ast.ProcCall{
		Token: p.curToken,
		Name:  p.curToken.Literal,
	}

	if !p.peekTokenIs(lexer.LPAREN) {
		// No arguments
		return call
	}

	p.nextToken() // consume (

	if p.peekTokenIs(lexer.RPAREN) {
		p.nextToken() // consume )
		return call
	}

	p.nextToken() // move to first arg
	call.Args = append(call.Args, p.parseExpression(LOWEST))

	for p.peekTokenIs(lexer.COMMA) {
		p.nextToken() // consume comma
		p.nextToken() // move to next arg
		call.Args = append(call.Args, p.parseExpression(LOWEST))
	}

	if !p.expectPeek(lexer.RPAREN) {
		return nil
	}

	return call
}

func (p *Parser) parseWhileLoop() *ast.WhileLoop {
	loop := &ast.WhileLoop{Token: p.curToken}

	p.nextToken()
	loop.Condition = p.parseExpression(LOWEST)

	// Skip to next line
	for p.peekTokenIs(lexer.NEWLINE) {
		p.nextToken()
	}

	// Expect INDENT
	if !p.peekTokenIs(lexer.INDENT) {
		p.addError("expected indented block after WHILE condition")
		return loop
	}
	p.nextToken() // consume INDENT
	p.nextToken() // move to first statement

	loop.Body = p.parseStatement()

	// Consume until DEDENT
	for !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
		p.nextToken()
	}

	return loop
}

func (p *Parser) parseIfStatement() *ast.IfStatement {
	stmt := &ast.IfStatement{Token: p.curToken}

	// Skip to next line
	for p.peekTokenIs(lexer.NEWLINE) {
		p.nextToken()
	}

	// Expect INDENT
	if !p.peekTokenIs(lexer.INDENT) {
		p.addError("expected indented block after IF")
		return stmt
	}
	p.nextToken() // consume INDENT
	p.nextToken() // move into block

	// Parse if choices (condition -> body pairs)
	for !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
		// Skip newlines
		for p.curTokenIs(lexer.NEWLINE) {
			p.nextToken()
		}

		if p.curTokenIs(lexer.DEDENT) {
			break
		}

		choice := ast.IfChoice{}
		choice.Condition = p.parseExpression(LOWEST)

		// Skip newlines and expect INDENT for body
		for p.peekTokenIs(lexer.NEWLINE) {
			p.nextToken()
		}

		if p.peekTokenIs(lexer.INDENT) {
			p.nextToken() // consume INDENT
			p.nextToken() // move to body
			choice.Body = p.parseStatement()

			// Consume until DEDENT
			for !p.curTokenIs(lexer.DEDENT) && !p.curTokenIs(lexer.EOF) {
				p.nextToken()
			}
		}

		stmt.Choices = append(stmt.Choices, choice)
		p.nextToken()
	}

	return stmt
}

// Expression parsing using Pratt parsing

func (p *Parser) parseExpression(precedence int) ast.Expression {
	var left ast.Expression

	switch p.curToken.Type {
	case lexer.IDENT:
		left = &ast.Identifier{Token: p.curToken, Value: p.curToken.Literal}
	case lexer.INT:
		val, err := strconv.ParseInt(p.curToken.Literal, 10, 64)
		if err != nil {
			p.addError(fmt.Sprintf("could not parse %q as integer", p.curToken.Literal))
			return nil
		}
		left = &ast.IntegerLiteral{Token: p.curToken, Value: val}
	case lexer.TRUE:
		left = &ast.BooleanLiteral{Token: p.curToken, Value: true}
	case lexer.FALSE:
		left = &ast.BooleanLiteral{Token: p.curToken, Value: false}
	case lexer.LPAREN:
		p.nextToken()
		left = p.parseExpression(LOWEST)
		if !p.expectPeek(lexer.RPAREN) {
			return nil
		}
	case lexer.MINUS:
		token := p.curToken
		p.nextToken()
		left = &ast.UnaryExpr{
			Token:    token,
			Operator: "-",
			Right:    p.parseExpression(PREFIX),
		}
	case lexer.NOT:
		token := p.curToken
		p.nextToken()
		left = &ast.UnaryExpr{
			Token:    token,
			Operator: "NOT",
			Right:    p.parseExpression(PREFIX),
		}
	default:
		p.addError(fmt.Sprintf("unexpected token in expression: %s", p.curToken.Type))
		return nil
	}

	// Parse infix expressions
	for !p.peekTokenIs(lexer.NEWLINE) && !p.peekTokenIs(lexer.EOF) &&
		precedence < p.peekPrecedence() {

		switch p.peekToken.Type {
		case lexer.PLUS, lexer.MINUS, lexer.MULTIPLY, lexer.DIVIDE, lexer.MODULO,
			lexer.EQ, lexer.NEQ, lexer.LT, lexer.GT, lexer.LE, lexer.GE,
			lexer.AND, lexer.OR:
			p.nextToken()
			left = p.parseBinaryExpr(left)
		default:
			return left
		}
	}

	return left
}

func (p *Parser) parseBinaryExpr(left ast.Expression) ast.Expression {
	expr := &ast.BinaryExpr{
		Token:    p.curToken,
		Left:     left,
		Operator: p.curToken.Literal,
	}

	prec := p.curPrecedence()
	p.nextToken()
	expr.Right = p.parseExpression(prec)

	return expr
}

package parser

import (
	"testing"

	"github.com/codeassociates/occam2go/ast"
	"github.com/codeassociates/occam2go/lexer"
)

func TestVarDecl(t *testing.T) {
	input := `INT x:
`
	l := lexer.New(input)
	p := New(l)
	program := p.ParseProgram()
	checkParserErrors(t, p)

	if len(program.Statements) != 1 {
		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
	}

	decl, ok := program.Statements[0].(*ast.VarDecl)
	if !ok {
		t.Fatalf("expected VarDecl, got %T", program.Statements[0])
	}

	if decl.Type != "INT" {
		t.Errorf("expected type INT, got %s", decl.Type)
	}

	if len(decl.Names) != 1 || decl.Names[0] != "x" {
		t.Errorf("expected name 'x', got %v", decl.Names)
	}
}

func TestMultipleVarDecl(t *testing.T) {
	input := `INT x, y, z:
`
	l := lexer.New(input)
	p := New(l)
	program := p.ParseProgram()
	checkParserErrors(t, p)

	if len(program.Statements) != 1 {
		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
	}

	decl, ok := program.Statements[0].(*ast.VarDecl)
	if !ok {
		t.Fatalf("expected VarDecl, got %T", program.Statements[0])
	}

	expected := []string{"x", "y", "z"}
	if len(decl.Names) != len(expected) {
		t.Fatalf("expected %d names, got %d", len(expected), len(decl.Names))
	}
	for i, name := range expected {
		if decl.Names[i] != name {
			t.Errorf("expected name %s at position %d, got %s", name, i, decl.Names[i])
		}
	}
}

func TestAssignment(t *testing.T) {
	input := `x := 5
`
	l := lexer.New(input)
	p := New(l)
	program := p.ParseProgram()
	checkParserErrors(t, p)

	if len(program.Statements) != 1 {
		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
	}

	assign, ok := program.Statements[0].(*ast.Assignment)
	if !ok {
		t.Fatalf("expected Assignment, got %T", program.Statements[0])
	}

	if assign.Name != "x" {
		t.Errorf("expected name 'x', got %s", assign.Name)
	}

	intLit, ok := assign.Value.(*ast.IntegerLiteral)
	if !ok {
		t.Fatalf("expected IntegerLiteral, got %T", assign.Value)
	}

	if intLit.Value != 5 {
		t.Errorf("expected value 5, got %d", intLit.Value)
	}
}

func TestBinaryExpression(t *testing.T) {
	input := `x := a + b * c
`
	l := lexer.New(input)
	p := New(l)
	program := p.ParseProgram()
	checkParserErrors(t, p)

	if len(program.Statements) != 1 {
		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
	}

	assign, ok := program.Statements[0].(*ast.Assignment)
	if !ok {
		t.Fatalf("expected Assignment, got %T", program.Statements[0])
	}

	// Should be: a + (b * c) due to precedence
	binExpr, ok := assign.Value.(*ast.BinaryExpr)
	if !ok {
		t.Fatalf("expected BinaryExpr, got %T", assign.Value)
	}

	if binExpr.Operator != "+" {
		t.Errorf("expected +, got %s", binExpr.Operator)
	}

	// Right side should be b * c
	rightBin, ok := binExpr.Right.(*ast.BinaryExpr)
	if !ok {
		t.Fatalf("expected right to be BinaryExpr, got %T", binExpr.Right)
	}

	if rightBin.Operator != "*" {
		t.Errorf("expected *, got %s", rightBin.Operator)
	}
}

func TestSeqBlock(t *testing.T) {
	input := `SEQ
  INT x:
  x := 10
`
	l := lexer.New(input)
	p := New(l)
	program := p.ParseProgram()
	checkParserErrors(t, p)

	if len(program.Statements) != 1 {
		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
	}

	seq, ok := program.Statements[0].(*ast.SeqBlock)
	if !ok {
		t.Fatalf("expected SeqBlock, got %T", program.Statements[0])
	}

	if len(seq.Statements) != 2 {
		t.Fatalf("expected 2 statements in SEQ, got %d", len(seq.Statements))
	}

	_, ok = seq.Statements[0].(*ast.VarDecl)
	if !ok {
		t.Errorf("expected first statement to be VarDecl, got %T", seq.Statements[0])
	}

	_, ok = seq.Statements[1].(*ast.Assignment)
	if !ok {
		t.Errorf("expected second statement to be Assignment, got %T", seq.Statements[1])
	}
}

func TestParBlock(t *testing.T) {
	input := `PAR
  x := 1
  y := 2
`
	l := lexer.New(input)
	p := New(l)
	program := p.ParseProgram()
	checkParserErrors(t, p)

	if len(program.Statements) != 1 {
		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
	}

	par, ok := program.Statements[0].(*ast.ParBlock)
	if !ok {
		t.Fatalf("expected ParBlock, got %T", program.Statements[0])
	}

	if len(par.Statements) != 2 {
		t.Fatalf("expected 2 statements in PAR, got %d", len(par.Statements))
	}
}

func checkParserErrors(t *testing.T, p *Parser) {
	errors := p.Errors()
	if len(errors) == 0 {
		return
	}

	t.Errorf("parser has %d errors:", len(errors))
	for _, msg := range errors {
		t.Errorf("  parser error: %s", msg)
	}
	t.FailNow()
}

package codegen

import (
	"fmt"
	"strings"

	"github.com/codeassociates/occam2go/ast"
)

// Generator converts an AST to Go code
type Generator struct {
	indent   int
	builder  strings.Builder
	needSync bool // track if we need sync package import
}

// New creates a new code generator
func New() *Generator {
	return &Generator{}
}

// Generate produces Go code from the AST
func (g *Generator) Generate(program *ast.Program) string {
	g.builder.Reset()
	g.needSync = false

	// First pass: check if we need sync package
	for _, stmt := range program.Statements {
		if g.containsPar(stmt) {
			g.needSync = true
			break
		}
	}

	// Write package declaration
	g.writeLine("package main")
	g.writeLine("")

	// Write imports
	if g.needSync {
		g.writeLine("import (")
		g.indent++
		g.writeLine(`"sync"`)
		g.indent--
		g.writeLine(")")
		g.writeLine("")
	}

	// Generate statements
	for _, stmt := range program.Statements {
		g.generateStatement(stmt)
	}

	return g.builder.String()
}

func (g *Generator) containsPar(stmt ast.Statement) bool {
	switch s := stmt.(type) {
	case *ast.ParBlock:
		return true
	case *ast.SeqBlock:
		for _, inner := range s.Statements {
			if g.containsPar(inner) {
				return true
			}
		}
	case *ast.ProcDecl:
		if s.Body != nil && g.containsPar(s.Body) {
			return true
		}
	case *ast.WhileLoop:
		if s.Body != nil && g.containsPar(s.Body) {
			return true
		}
	case *ast.IfStatement:
		for _, choice := range s.Choices {
			if choice.Body != nil && g.containsPar(choice.Body) {
				return true
			}
		}
	}
	return false
}

func (g *Generator) writeLine(s string) {
	if s == "" {
		g.builder.WriteString("\n")
		return
	}
	g.builder.WriteString(strings.Repeat("\t", g.indent))
	g.builder.WriteString(s)
	g.builder.WriteString("\n")
}

func (g *Generator) write(s string) {
	g.builder.WriteString(s)
}

func (g *Generator) generateStatement(stmt ast.Statement) {
	switch s := stmt.(type) {
	case *ast.VarDecl:
		g.generateVarDecl(s)
	case *ast.Assignment:
		g.generateAssignment(s)
	case *ast.SeqBlock:
		g.generateSeqBlock(s)
	case *ast.ParBlock:
		g.generateParBlock(s)
	case *ast.Skip:
		g.writeLine("// SKIP")
	case *ast.ProcDecl:
		g.generateProcDecl(s)
	case *ast.ProcCall:
		g.generateProcCall(s)
	case *ast.WhileLoop:
		g.generateWhileLoop(s)
	case *ast.IfStatement:
		g.generateIfStatement(s)
	}
}

func (g *Generator) generateVarDecl(decl *ast.VarDecl) {
	goType := g.occamTypeToGo(decl.Type)
	g.writeLine(fmt.Sprintf("var %s %s", strings.Join(decl.Names, ", "), goType))
}

func (g *Generator) occamTypeToGo(occamType string) string {
	switch occamType {
	case "INT":
		return "int"
	case "BYTE":
		return "byte"
	case "BOOL":
		return "bool"
	case "REAL":
		return "float64"
	default:
		return occamType // pass through unknown types
	}
}

func (g *Generator) generateAssignment(assign *ast.Assignment) {
	g.builder.WriteString(strings.Repeat("\t", g.indent))
	g.write(assign.Name)
	g.write(" = ")
	g.generateExpression(assign.Value)
	g.write("\n")
}

func (g *Generator) generateSeqBlock(seq *ast.SeqBlock) {
	// SEQ just becomes sequential Go code (Go's default)
	for _, stmt := range seq.Statements {
		g.generateStatement(stmt)
	}
}

func (g *Generator) generateParBlock(par *ast.ParBlock) {
	// PAR becomes goroutines with WaitGroup
	g.writeLine("var wg sync.WaitGroup")
	g.writeLine(fmt.Sprintf("wg.Add(%d)", len(par.Statements)))

	for _, stmt := range par.Statements {
		g.writeLine("go func() {")
		g.indent++
		g.writeLine("defer wg.Done()")
		g.generateStatement(stmt)
		g.indent--
		g.writeLine("}()")
	}

	g.writeLine("wg.Wait()")
}

func (g *Generator) generateProcDecl(proc *ast.ProcDecl) {
	// Generate function signature
	params := g.generateProcParams(proc.Params)
	g.writeLine(fmt.Sprintf("func %s(%s) {", proc.Name, params))
	g.indent++

	if proc.Body != nil {
		g.generateStatement(proc.Body)
	}

	g.indent--
	g.writeLine("}")
	g.writeLine("")
}

func (g *Generator) generateProcParams(params []ast.ProcParam) string {
	var parts []string
	for _, p := range params {
		goType := g.occamTypeToGo(p.Type)
		if !p.IsVal {
			// Non-VAL parameters are pass by reference in Occam
			goType = "*" + goType
		}
		parts = append(parts, fmt.Sprintf("%s %s", p.Name, goType))
	}
	return strings.Join(parts, ", ")
}

func (g *Generator) generateProcCall(call *ast.ProcCall) {
	g.builder.WriteString(strings.Repeat("\t", g.indent))
	g.write(call.Name)
	g.write("(")
	for i, arg := range call.Args {
		if i > 0 {
			g.write(", ")
		}
		g.generateExpression(arg)
	}
	g.write(")")
	g.write("\n")
}

func (g *Generator) generateWhileLoop(loop *ast.WhileLoop) {
	g.builder.WriteString(strings.Repeat("\t", g.indent))
	g.write("for ")
	g.generateExpression(loop.Condition)
	g.write(" {\n")
	g.indent++

	if loop.Body != nil {
		g.generateStatement(loop.Body)
	}

	g.indent--
	g.writeLine("}")
}

func (g *Generator) generateIfStatement(stmt *ast.IfStatement) {
	for i, choice := range stmt.Choices {
		g.builder.WriteString(strings.Repeat("\t", g.indent))
		if i == 0 {
			g.write("if ")
		} else {
			g.write("} else if ")
		}
		g.generateExpression(choice.Condition)
		g.write(" {\n")
		g.indent++

		if choice.Body != nil {
			g.generateStatement(choice.Body)
		}

		g.indent--
	}
	g.writeLine("}")
}

func (g *Generator) generateExpression(expr ast.Expression) {
	switch e := expr.(type) {
	case *ast.Identifier:
		g.write(e.Value)
	case *ast.IntegerLiteral:
		g.write(fmt.Sprintf("%d", e.Value))
	case *ast.BooleanLiteral:
		if e.Value {
			g.write("true")
		} else {
			g.write("false")
		}
	case *ast.BinaryExpr:
		g.generateBinaryExpr(e)
	case *ast.UnaryExpr:
		g.generateUnaryExpr(e)
	case *ast.ParenExpr:
		g.write("(")
		g.generateExpression(e.Expr)
		g.write(")")
	}
}

func (g *Generator) generateBinaryExpr(expr *ast.BinaryExpr) {
	g.write("(")
	g.generateExpression(expr.Left)
	g.write(" ")
	g.write(g.occamOpToGo(expr.Operator))
	g.write(" ")
	g.generateExpression(expr.Right)
	g.write(")")
}

func (g *Generator) generateUnaryExpr(expr *ast.UnaryExpr) {
	op := g.occamOpToGo(expr.Operator)
	g.write(op)
	if op == "!" {
		// Go's NOT doesn't need space
	} else {
		g.write(" ")
	}
	g.generateExpression(expr.Right)
}

func (g *Generator) occamOpToGo(op string) string {
	switch op {
	case "=":
		return "=="
	case "<>":
		return "!="
	case "AND":
		return "&&"
	case "OR":
		return "||"
	case "NOT":
		return "!"
	case "\\":
		return "%"
	default:
		return op // +, -, *, /, <, >, <=, >= are the same
	}
}

package codegen

import (
	"strings"
	"testing"

	"github.com/codeassociates/occam2go/lexer"
	"github.com/codeassociates/occam2go/parser"
)

func TestSimpleVarDecl(t *testing.T) {
	input := `INT x:
`
	output := transpile(t, input)

	if !strings.Contains(output, "var x int") {
		t.Errorf("expected 'var x int' in output, got:\n%s", output)
	}
}

func TestMultipleVarDecl(t *testing.T) {
	input := `INT x, y, z:
`
	output := transpile(t, input)

	if !strings.Contains(output, "var x, y, z int") {
		t.Errorf("expected 'var x, y, z int' in output, got:\n%s", output)
	}
}

func TestAssignment(t *testing.T) {
	input := `x := 42
`
	output := transpile(t, input)

	if !strings.Contains(output, "x = 42") {
		t.Errorf("expected 'x = 42' in output, got:\n%s", output)
	}
}

func TestBinaryExpression(t *testing.T) {
	input := `x := a + b
`
	output := transpile(t, input)

	if !strings.Contains(output, "x = (a + b)") {
		t.Errorf("expected 'x = (a + b)' in output, got:\n%s", output)
	}
}

func TestComparisonOperators(t *testing.T) {
	tests := []struct {
		input    string
		expected string
	}{
		{"x := a = b\n", "x = (a == b)"},
		{"x := a <> b\n", "x = (a != b)"},
	}

	for _, tt := range tests {
		output := transpile(t, tt.input)
		if !strings.Contains(output, tt.expected) {
			t.Errorf("expected %q in output, got:\n%s", tt.expected, output)
		}
	}
}

func TestSeqBlock(t *testing.T) {
	input := `SEQ
  INT x:
  x := 10
`
	output := transpile(t, input)

	// SEQ becomes sequential Go code
	if !strings.Contains(output, "var x int") {
		t.Errorf("expected 'var x int' in output, got:\n%s", output)
	}
	if !strings.Contains(output, "x = 10") {
		t.Errorf("expected 'x = 10' in output, got:\n%s", output)
	}
}

func TestParBlock(t *testing.T) {
	input := `PAR
  x := 1
  y := 2
`
	output := transpile(t, input)

	// PAR should use sync.WaitGroup
	if !strings.Contains(output, "sync.WaitGroup") {
		t.Errorf("expected sync.WaitGroup in output, got:\n%s", output)
	}
	if !strings.Contains(output, "wg.Add(2)") {
		t.Errorf("expected wg.Add(2) in output, got:\n%s", output)
	}
	if !strings.Contains(output, "go func()") {
		t.Errorf("expected 'go func()' in output, got:\n%s", output)
	}
	if !strings.Contains(output, "wg.Wait()") {
		t.Errorf("expected wg.Wait() in output, got:\n%s", output)
	}
}

func TestProcDecl(t *testing.T) {
	input := `PROC foo(VAL INT x)
  y := x
`
	output := transpile(t, input)

	if !strings.Contains(output, "func foo(x int)") {
		t.Errorf("expected 'func foo(x int)' in output, got:\n%s", output)
	}
}

func TestProcDeclWithRefParam(t *testing.T) {
	input := `PROC bar(INT x)
  x := 10
`
	output := transpile(t, input)

	// Non-VAL parameter should be pointer
	if !strings.Contains(output, "func bar(x *int)") {
		t.Errorf("expected 'func bar(x *int)' in output, got:\n%s", output)
	}
}

func transpile(t *testing.T, input string) string {
	t.Helper()

	l := lexer.New(input)
	p := parser.New(l)
	program := p.ParseProgram()

	if len(p.Errors()) > 0 {
		for _, err := range p.Errors() {
			t.Errorf("parser error: %s", err)
		}
		t.FailNow()
	}

	gen := New()
	return gen.Generate(program)
}

package main

import (
	"flag"
	"fmt"
	"os"

	"github.com/codeassociates/occam2go/codegen"
	"github.com/codeassociates/occam2go/lexer"
	"github.com/codeassociates/occam2go/parser"
)

const version = "0.1.0"

func main() {
	showVersion := flag.Bool("version", false, "Print version and exit")
	outputFile := flag.String("o", "", "Output file (default: stdout)")

	flag.Usage = func() {
		fmt.Fprintf(os.Stderr, "occam2go - An Occam to Go transpiler\n\n")
		fmt.Fprintf(os.Stderr, "Usage: %s [options] <input.occ>\n\n", os.Args[0])
		fmt.Fprintf(os.Stderr, "Options:\n")
		flag.PrintDefaults()
	}

	flag.Parse()

	if *showVersion {
		fmt.Printf("occam2go version %s\n", version)
		os.Exit(0)
	}

	args := flag.Args()
	if len(args) < 1 {
		flag.Usage()
		os.Exit(1)
	}

	inputFile := args[0]

	// Read input file
	input, err := os.ReadFile(inputFile)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error reading file: %s\n", err)
		os.Exit(1)
	}

	// Lex
	l := lexer.New(string(input))

	// Parse
	p := parser.New(l)
	program := p.ParseProgram()

	if len(p.Errors()) > 0 {
		fmt.Fprintf(os.Stderr, "Parse errors:\n")
		for _, err := range p.Errors() {
			fmt.Fprintf(os.Stderr, "  %s\n", err)
		}
		os.Exit(1)
	}

	// Generate Go code
	gen := codegen.New()
	output := gen.Generate(program)

	// Write output
	if *outputFile != "" {
		err := os.WriteFile(*outputFile, []byte(output), 0644)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Error writing file: %s\n", err)
			os.Exit(1)
		}
	} else {
		fmt.Print(output)
	}
}

-- A simple Occam program
SEQ
  INT x, y:
  x := 10
  y := 20
  x := x + y

-- Parallel execution example
SEQ
  INT x, y:
  PAR
    x := 1
    y := 2
  x := x + y