package main

import (
    "fmt"
    "github.com/codetesla51/golexer/golexer"
)

func main() {
    source := `let total = 42 + 3.14 * count;`
    lexer := golexer.NewLexer(source)
    
    for {
        token := lexer.NextToken()
        if token.Type == golexer.EOF {
            break
        }
        fmt.Printf("%-12s %-10s (Line %d, Col %d)\n", 
            token.Type, token.Literal, token.Line, token.Column)
    }
}

lexer := golexer.NewLexer(source)
tokens, errors := lexer.TokenizeAll()

fmt.Printf("Generated %d tokens\n", len(tokens))

if len(errors) > 0 {
    fmt.Printf("Found %d errors:\n", len(errors))
    for _, err := range errors {
        fmt.Printf("  %s\n", err.Error())
    }
} else {
    fmt.Println("No lexical errors found")
}

lexer := golexer.NewLexerWithConfig(source, "examples/config.json")

// Now recognizes extended syntax:
source := `
unless error {
    result = value ** 2 ?? fallback
    data = object ?. property
    user = @currentUser
}
`

"Hello, World!"           // Simple string
"Line 1\nLine 2"         // Newline
"Quote: \"Hello\""       // Escaped quote
"Tab\tSeparated"         // Tab character
"Hex: \x41\x42"          // Hex escapes (AB)

`Raw string with \n literal backslashes`
`File path: C:\Users\Name\file.txt`
`Multi
line
string`

'a', 'Z', '0'            // Regular characters
'\n', '\t', '\r'         // Control characters
'\'', '\\'               // Escaped quotes
'\x41'                   // Hex escape for 'A'

// Line comments - rest of line ignored
let x = 42; // End of line comment

/* Block comments - can span multiple lines */
let y = /* inline */ 10;

// Create basic lexer
func NewLexer(input string) *Lexer

// Create lexer with JSON configuration
func NewLexerWithConfig(input, configFile string) *Lexer

// Get next token (streaming)
func (l *Lexer) NextToken() Token

// Get all tokens at once (batch)
func (l *Lexer) TokenizeAll() ([]Token, []*LexError)

// Check for errors
func (l *Lexer) HasErrors() bool

// Get error details
func (l *Lexer) GetErrors() []*LexError

type Token struct {
    Type    TokenType  // Token classification
    Literal string     // Original text
    Line    int        // Line number (1-indexed)
    Column  int        // Column position (1-indexed)
}

type LexError struct {
    Message string     // Error description
    Line    int        // Error line
    Column  int        // Error column
}

problemSource := `
let x = 123abc;      // Error: invalid number
let y = "valid";     // Continues processing
let z = 0xGHI;       // Error: invalid hex
let a = 42;          // Still processes correctly
`

lexer := golexer.NewLexer(problemSource)
tokens, errors := lexer.TokenizeAll()

// Result: 
// - tokens contains all valid tokens including "valid" and 42
// - errors contains detailed info about both problems
// - Processing never stops due to errors

type Compiler struct {
    lexer *golexer.Lexer
}

func (c *Compiler) CompileFile(filename string) error {
    source, err := os.ReadFile(filename)
    if err != nil {
        return err
    }
    
    c.lexer = golexer.NewLexer(string(source))
    tokens, errors := c.lexer.TokenizeAll()
    
    if len(errors) > 0 {
        return fmt.Errorf("lexical errors: %v", errors)
    }
    
    // Pass tokens to parser
    return c.parse(tokens)
}

func ParseConfig(configFile string) (*AppConfig, error) {
    content, err := os.ReadFile(configFile)
    if err != nil {
        return nil, err
    }
    
    lexer := golexer.NewLexerWithConfig(string(content), "config-lang.json")
    config := &AppConfig{}
    
    for {
        tok := lexer.NextToken()
        if tok.Type == golexer.EOF {
            break
        }
        
        // Parse key: value pairs
        if tok.Type == golexer.IDENT {
            key := tok.Literal
            if colon := lexer.NextToken(); colon.Type == golexer.COLON {
                value := lexer.NextToken()
                config.Set(key, parseValue(value))
            }
        }
    }
    
    return config, nil
}

func AnalyzeCode(source string) {
    lexer := golexer.NewLexer(source)
    tokens, errors := lexer.TokenizeAll()
    
    // Generate statistics
    tokenCounts := make(map[golexer.TokenType]int)
    for _, token := range tokens {
        tokenCounts[token.Type]++
    }
    
    fmt.Printf("Analysis Results:\n")
    fmt.Printf("Total tokens: %d\n", len(tokens))
    fmt.Printf("Unique types: %d\n", len(tokenCounts))
    fmt.Printf("Errors found: %d\n", len(errors))
    
    // Show token distribution
    for tokenType, count := range tokenCounts {
        percentage := float64(count) / float64(len(tokens)) * 100
        fmt.Printf("  %-15s: %4d (%5.1f%%)\n", tokenType, count, percentage)
    }
}

func GenerateHighlighting(source string) []HighlightToken {
    lexer := golexer.NewLexer(source)
    var highlights []HighlightToken
    
    for {
        tok := lexer.NextToken()
        if tok.Type == golexer.EOF {
            break
        }
        
        highlights = append(highlights, HighlightToken{
            Text:   tok.Literal,
            Type:   mapToHighlightType(tok.Type),
            Line:   tok.Line,
            Column: tok.Column,
        })
    }
    
    return highlights
}

func mapToHighlightType(tokenType golexer.TokenType) string {
    switch tokenType {
    case golexer.LET, golexer.IF, golexer.WHILE:
        return "keyword"
    case golexer.STRING, golexer.CHAR:
        return "string"
    case golexer.NUMBER:
        return "number"
    default:
        return "default"
    }
}