main.go

package main

import (
	"fmt"
	"grua/src"
	"grua/src/lexer"
	"grua/src/parser"
	"grua/src/runtime"
	"os"
	"path/filepath"
	"strings"
)

var (
	parsedFiles       = make(map[string]bool)
	globalSymbolTable = make(map[string]parser.Symbol)
	stdlibDir         string
)

func init() {
	// Figure out where the compiler is running from to establish the stdlib path
	ex, err := os.Executable()
	if err != nil {
		panic(err)
	}
	compilerDir := filepath.Dir(ex)
	stdlibDir = filepath.Join(compilerDir, "../stdlib/")
}

func main() {
	args := os.Args[1:]
	filepathArg := src.GetFilePath(args)
	shouldRun := src.HasRunFlag(args)

	if filepathArg == "" {
		fmt.Println("Usage: grua --file <yourfile.grua> [--run]")
		os.Exit(1)
	}

	// Enforce that the entry file is strictly a .grua file
	if !strings.HasSuffix(filepathArg, ".grua") {
		fmt.Printf("Build Error: Invalid file extension. The compiler only accepts '.grua' files.\nProvided: %s\n", filepathArg)
		os.Exit(1)
	}

	fmt.Printf("Building Project starting from %s...\n", filepathArg)

	// Process the main entry file (which will recursively process imports)
	mainAST := processModule(filepathArg)

	// In an interpreted language, we execute the AST directly instead of building binaries
	if shouldRun {
		fmt.Println("========================================")
		fmt.Printf("Executing: %s\n", filepathArg)
		fmt.Println("----------------------------------------")

		// 1. Create the Global Environment
		globalEnv := runtime.NewEnvironment(nil)

		// 2. Evaluate the AST
		result, err := runtime.Evaluate(mainAST, globalEnv)
		if err != nil {
			fmt.Printf("Execution Failed:\n%v\n", err)
			os.Exit(1)
		}

		// 3. Print the final evaluation result (temporary, just to see it work!)
		if result != nil && result.Type() != runtime.NullValueType {
			fmt.Printf("Program exited with value: %s\n", result.Inspect())
		}

		fmt.Println("========================================")
	} else {
		fmt.Println("Parse and Borrow-Check completed successfully. (AST generated)")
	}
}

func processModule(currentFilepath string) *parser.Program {
	// Enforce that all imported/processed modules are strictly .grua files
	if !strings.HasSuffix(currentFilepath, ".grua") {
		fmt.Printf("Build Error: Invalid module extension. Only '.grua' files can be imported.\nTarget: %s\n", currentFilepath)
		os.Exit(1)
	}

	// Prevent circular imports and duplicate parsing
	absPath, err := filepath.Abs(currentFilepath)
	if err != nil {
		absPath = currentFilepath
	}
	if parsedFiles[absPath] {
		return nil
	}
	parsedFiles[absPath] = true

	if !src.FileExists(currentFilepath) {
		fmt.Printf("Build Error: Module file not found -> %s\n", currentFilepath)
		os.Exit(1)
	}

	fmt.Printf("Compiling: %s...\n", currentFilepath)
	lines := src.LinesFrom(currentFilepath)
	sourceCode := strings.Join(lines, "\n")
	currentDir := filepath.Dir(currentFilepath)

	// 1. Lexical Analysis
	l := &lexer.Lexer{}
	err = l.Tokenize(sourceCode)
	if err != nil {
		fmt.Printf("Lexer Error in %s: %v\n", currentFilepath, err)
		os.Exit(1)
	}

	// 2. Pre-scan tokens for imports to resolve dependencies before parsing
	// This ensures the global symbol table is populated with imported types/functions
	for i := 0; i < len(l.Tokens); i++ {
		if l.Tokens[i].Type == lexer.TokenImport {
			if i+1 < len(l.Tokens) && l.Tokens[i+1].Type == lexer.TokenString {
				rawPath := l.Tokens[i+1].Literal
				localPath := filepath.Join(currentDir, rawPath+".grua")
				stdlibPath := filepath.Join(stdlibDir, rawPath+".grua")

				targetPath := ""
				if src.FileExists(localPath) {
					targetPath = localPath
				} else if src.FileExists(stdlibPath) {
					targetPath = stdlibPath
				} else {
					fmt.Printf("Build Error: Cannot resolve import '%s'. Checked local (%s) and stdlib (%s).\n", rawPath, localPath, stdlibPath)
					os.Exit(1)
				}

				// Recursively parse the imported module
				processModule(targetPath)
			}
		}
	}

	// 3. Parsing (Using the shared globalSymbolTable)
	p := parser.NewParser(l.Tokens, globalSymbolTable)
	ast := p.Parse()

	// 4. Borrow Checking
	fmt.Printf("Running Borrow Checker for %s...\n", currentFilepath)
	bc := runtime.NewBorrowChecker(globalSymbolTable)
	if err := bc.Verify(ast); err != nil {
		fmt.Printf("Compilation halted due to Borrow Checker violations in %s:\n%v\n", currentFilepath, err)
		os.Exit(1)
	}

	return ast
}