main.go

// Command sdg is the SDGScript interpreter — the sustainable programming language.
//
// Usage:
//
//	sdg run <file.sdg> [--report]
//	sdg repl
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"

	"github.com/sdgscript/sdg/evaluator"
	"github.com/sdgscript/sdg/lexer"
	"github.com/sdgscript/sdg/object"
	"github.com/sdgscript/sdg/parser"
)

const banner = "SDGScript 🌱 — the sustainable programming language"

func main() {
	args := os.Args[1:]
	if len(args) == 0 {
		usage()
		os.Exit(1)
	}

	switch args[0] {
	case "run":
		if len(args) < 2 {
			fmt.Fprintln(os.Stderr, "sdg run needs a file: sdg run program.sdg")
			os.Exit(1)
		}
		showReport := hasFlag(args[2:], "--report")
		os.Exit(runFile(args[1], showReport))
	case "repl":
		repl()
	case "version", "--version", "-v":
		fmt.Println(banner)
	default:
		usage()
		os.Exit(1)
	}
}

func runFile(path string, showReport bool) int {
	src, err := os.ReadFile(path)
	if err != nil {
		fmt.Fprintf(os.Stderr, "cannot read %s: %v\n", path, err)
		return 1
	}

	l := lexer.New(string(src))
	p := parser.New(l)
	program := p.ParseProgram()
	if errs := p.Errors(); len(errs) > 0 {
		fmt.Fprintln(os.Stderr, "🌍 SDGScript could not parse your program:")
		for _, e := range errs {
			fmt.Fprintln(os.Stderr, "  -", e)
		}
		return 1
	}

	env := object.NewEnvironment()
	m := &evaluator.Meter{}
	result := evaluator.Eval(program, env, m)

	for _, line := range m.Output {
		fmt.Println(line)
	}

	if err, ok := result.(*object.Error); ok {
		fmt.Fprintln(os.Stderr, "\n🍂 "+err.Message)
		if showReport {
			fmt.Print(m.Report())
		}
		return 1
	}

	if showReport {
		fmt.Print(m.Report())
	}
	return 0
}

func repl() {
	fmt.Println(banner)
	fmt.Println("Type SDGScript; every session ends with a sustainability report. Ctrl-D to exit.")
	env := object.NewEnvironment()
	m := &evaluator.Meter{}
	scanner := bufio.NewScanner(os.Stdin)
	for {
		fmt.Print("🌱 ")
		if !scanner.Scan() {
			break
		}
		line := scanner.Text()
		if strings.TrimSpace(line) == "" {
			continue
		}
		l := lexer.New(line)
		p := parser.New(l)
		program := p.ParseProgram()
		if errs := p.Errors(); len(errs) > 0 {
			for _, e := range errs {
				fmt.Println("  -", e)
			}
			continue
		}
		// REPL runs are lenient: skip the top-level waste check so partial
		// snippets don't error on unconsumed bindings.
		result := evaluator.Eval(program, env, m)
		for _, out := range m.Output {
			fmt.Println(out)
		}
		m.Output = nil
		if err, ok := result.(*object.Error); ok {
			fmt.Println("🍂 " + err.Message)
		} else if result != nil && result.Type() != object.NULL {
			fmt.Println(result.Inspect())
		}
	}
	fmt.Print(m.Report())
}

func hasFlag(args []string, flag string) bool {
	for _, a := range args {
		if a == flag {
			return true
		}
	}
	return false
}

func usage() {
	fmt.Println(banner)
	fmt.Println("\nUsage:")
	fmt.Println("  sdg run <file.sdg> [--report]   run a program")
	fmt.Println("  sdg repl                        start an interactive session")
	fmt.Println("  sdg version                     print version")
}