using ToonTokenizer;

var source = @"
users[2]{id,name,role}:
  1,Alice,admin
  2,Bob,user
";

// Parse returns: Document (AST), Errors (if any), and Tokens
var result = Toon.Parse(source);

if (result.IsSuccess)
{
    // Access the parsed document
    foreach (var property in result.Document.Properties)
    {
        Console.WriteLine($"{property.Key}: {property.Value}");
    }
    
    // Access tokens for syntax highlighting
    foreach (var token in result.Tokens)
    {
        Console.WriteLine($"{token.Type}: '{token.Value}' at {token.Line}:{token.Column}");
    }
}
else
{
    // Resilient parsing: you still get a partial AST + all errors
    Console.WriteLine($"Found {result.Errors.Count} error(s):");
    foreach (var error in result.Errors)
    {
        Console.WriteLine($"  Line {error.Line}: {error.Message}");
    }
}

if (Toon.TryParse(source, out var result))
{
    if (result.IsSuccess)
        Console.WriteLine("✓ Valid TOON");
    else
        Console.WriteLine($"✗ {result.Errors.Count} error(s) found");
}

// Get tokens without parsing
var tokens = Toon.Tokenize(source);

foreach (var token in tokens)
{
    Console.WriteLine($"{token.Type}: {token.Value}");
}

var source = "name: John\nage: 30";
var result = Toon.Parse(source);

// Get a token and find which AST node it belongs to
var token = result.Tokens.Find(t => t.Value == "30");
var property = token.GetPropertyNode(result.Document);

Console.WriteLine($"Token '{token.Value}' belongs to property: {property.Key}");
// Output: Token '30' belongs to property: age

// Or find property at a specific line/column
var prop = result.GetPropertyAt(line: 2, column: 1);
Console.WriteLine($"Property at line 2: {prop.Key}");
// Output: Property at line 2: age

// Find nested properties by path
var theme = result.FindPropertyByPath("user.settings.theme");
if (theme?.Value is StringValueNode str)
{
    Console.WriteLine($"Theme: {str.Value}");
}

// Parse TOON source (returns Document, Errors, and Tokens)
ToonParseResult Parse(string source)

// Validate and parse (returns true for completed parse, even with errors)
bool TryParse(string source, out ToonParseResult result)

// Tokenize only
List<Token> Tokenize(string source)

public class ToonParseResult
{
    public ToonDocument Document { get; }      // Always available (even with errors)
    public List<ToonError> Errors { get; }     // Empty if no errors
    public List<Token> Tokens { get; }         // All tokens from lexing
    
    public bool IsSuccess => Errors.Count == 0;
    public bool HasErrors => Errors.Count > 0;
}

public class ToonError
{
    public string Message { get; }
    public string? Code { get; }      // Error code (e.g., "TOON1001")
    public int Position { get; }      // 0-based character offset
    public int Length { get; }        // Length of error span
    public int Line { get; }          // 1-based line number
    public int Column { get; }        // 1-based column number
    public int EndPosition { get; }   // Position + Length
}

var result = Toon.Parse(source);

foreach (var error in result.Errors)
{
    // Errors include descriptive messages with fix suggestions
    Console.WriteLine($"[{error.Code}] {error.Message}");
    
    // Filter by error type
    if (error.Code?.StartsWith("TOON1") == true)
        Console.WriteLine("  → Lexer/tokenization error");
    else if (error.Code?.StartsWith("TOON2") == true)
        Console.WriteLine("  → Parser structural error");
    else if (error.Code?.StartsWith("TOON3") == true)
        Console.WriteLine("  → Validation error");
}

// Unterminated string
[TOON1001] Unterminated double-quoted string at line 5, column 10. 
String reached end of line without closing " character. 
Fix: Add closing " before the end of the line

// Invalid escape sequence
[TOON1002] Invalid escape sequence '\x' at line 3, column 15. 
Valid escape sequences: \n, \r, \t, \\, \", \'. 
Fix: Use a valid escape sequence or remove the backslash

// Array size mismatch
[TOON3001] Array size mismatch: declared 5 elements, but found 3. 
Missing 2 elements. Check if array is incomplete or elements are on wrong indentation level. 
Fix: Either add 2 more elements or change the size declaration [5]→[3]

// Table size mismatch with helpful hint
[TOON3002] Table array size mismatch: declared 10 rows, but found 8. 
Missing 2 rows. Check if rows are incomplete or have incorrect indentation. 
Fix: Either add 2 more rows or update the size [10]→[8]

public enum TokenType
{
    // Values
    String, Number, True, False, Null, Identifier,
    
    // Structure
    Colon, Comma, Pipe,
    LeftBracket, RightBracket,
    LeftBrace, RightBrace,
    
    // Formatting
    Newline, Indent, Dedent, Whitespace,
    
    // Special
    Comment, EndOfFile, Invalid
}

// Document root
ToonDocument              // Contains Properties[]

// Structural
PropertyNode              // Key + Value
ObjectNode                // Nested object with Properties[]

// Arrays
ArrayNode                 // Simple array with Elements[]
TableArrayNode            // Tabular with Schema[] and Rows[][]

// Values
StringValueNode           // String literal
NumberValueNode           // Numeric (integer or float)
BooleanValueNode          // true/false
NullValueNode             // null

int StartLine, StartColumn, StartPosition
int EndLine, EndColumn, EndPosition

var source = @"
name: John
invalid line here
city: Boulder
";

var result = Toon.Parse(source);

// result.Document has 2 valid properties (name, city)
// result.Errors has 1 error (line 3)

using ToonTokenizer;

var tokens = Toon.Tokenize(source);

// Get tokens on specific line
var lineTokens = tokens.GetTokensOnLine(5);

// Find token at position
var token = tokens.GetTokenAt(line: 3, column: 10);

// Filter by type
var strings = tokens.GetTokensByType(TokenType.String);

// Syntax highlighting classification
foreach (var token in tokens)
{
    string cssClass = token.GetClassification();
    // Returns: "keyword", "string", "number", "comment", etc.
}

// Check categories
bool isKeyword = token.IsKeyword();        // true, false, null
bool isStructural = token.IsStructural();  // :, [, ], {, }, ,
bool isValue = token.IsValue();            // strings, numbers, booleans

using ToonTokenizer;
using ToonTokenizer.Ast;

var result = Toon.Parse(source);

// From token to AST node
var token = result.Tokens.GetTokenAt(line: 5, column: 3);
var node = token.GetAstNode(result.Document);
var property = token.GetPropertyNode(result.Document);

// From parse result directly
var nodeAtPosition = result.GetNodeAtPosition(42);
var nodeForToken = result.GetNodeForToken(myToken);
var propertyAt = result.GetPropertyAt(line: 3, column: 5);

// Get all properties (including nested)
var allProps = result.GetAllProperties();

// Find by path (dot notation)
var theme = result.FindPropertyByPath("user.settings.theme");
var email = result.FindPropertyByPath("user.email");

if (theme?.Value is StringValueNode str)
{
    Console.WriteLine($"Theme: {str.Value}");
}

using ToonTokenizer.Ast;

public class MyVisitor : IAstVisitor<string>
{
    public string VisitDocument(ToonDocument node)
    {
        var results = node.Properties.Select(p => p.Accept(this));
        return string.Join(", ", results);
    }
    
    public string VisitProperty(PropertyNode node)
    {
        return $"{node.Key} = {node.Value.Accept(this)}";
    }
    
    public string VisitStringValue(StringValueNode node)
    {
        return $"\"{node.Value}\"";
    }
    
    // ... implement other Visit methods
}

// Use it
var doc = Toon.Parse(source).Document;
var output = doc.Accept(new MyVisitor());

public IEnumerable<ClassificationSpan> GetClassificationSpans(SnapshotSpan span)
{
    var source = span.GetText();
    var result = Toon.Parse(source);  // Gets tokens + AST in one call
    
    foreach (var token in result.Tokens)
    {
        var classification = token.GetClassification();
        var tokenSpan = new SnapshotSpan(
            span.Snapshot, 
            token.Position, 
            token.Length
        );
        
        yield return new ClassificationSpan(
            tokenSpan, 
            GetClassificationType(classification)
        );
    }
}

public IEnumerable<Completion> GetCompletions(int line, int column)
{
    var result = Toon.Parse(documentText);
    
    // Find the property we're currently in
    var property = result.GetPropertyAt(line, column);
    
    if (property != null)
    {
        // Context-aware suggestions based on property type
        if (property.Value is ObjectNode)
        {
            // Suggest nested property names
            yield return new Completion("theme");
            yield return new Completion("enabled");
        }
        else if (property.Value is ArrayNode)
        {
            // Suggest array-specific completions
            yield return new Completion("[size]");
        }
    }
    
    var token = result.Tokens.GetTokenAt(line, column);
    if (token?.Type == TokenType.Colon)
    {
        // After colon: suggest value types
        yield return new Completion("true");
        yield return new Completion("false");
        yield return new Completion("null");
    }
}

public IEnumerable<Diagnostic> GetDiagnostics()
{
    var result = Toon.Parse(documentText);
    
    foreach (var error in result.Errors)
    {
        yield return new Diagnostic
        {
            Severity = DiagnosticSeverity.Error,
            Message = error.Message,
            Range = new Range(
                error.Line - 1,
                error.Column - 1,
                error.EndPosition
            )
        };
    }
}

public IEnumerable<FoldingRange> GetFoldingRanges()
{
    var result = Toon.Parse(documentText);
    
    foreach (var property in result.Document.Properties)
    {
        if (property.Value is ObjectNode obj && obj.Properties.Count > 0)
        {
            yield return new FoldingRange
            {
                StartLine = obj.StartLine,
                EndLine = obj.EndLine,
                Kind = FoldingRangeKind.Region
            };
        }
        else if (property.Value is TableArrayNode table && table.Rows.Count > 5)
        {
            yield return new FoldingRange
            {
                StartLine = table.StartLine,
                EndLine = table.EndLine,
                Kind = FoldingRangeKind.Region
            };
        }
    }
}

// Convert verbose JSON to compact TOON for token savings
var jsonData = GetDataFromApi();
var toonEncoder = new ToonEncoder();
var compactPrompt = toonEncoder.Encode(jsonData);

// Use in prompt
var prompt = $@"
Analyze this data:
{compactPrompt}

What insights can you provide?
";