using MarketAlly.IronGo;

// Parse Go source code
var source = @"
package main

import ""fmt""

func main() {
    fmt.Println(""Hello, World!"")
}";

var ast = IronGoParser.Parse(source);

// Access AST nodes
Console.WriteLine($"Package: {ast.Package.Name}");
Console.WriteLine($"Imports: {string.Join(", ", ast.GetImportedPackages())}");
Console.WriteLine($"Functions: {ast.GetFunctions().Count()}");

// Get detailed parsing information
var result = IronGoParser.ParseWithDiagnostics(source);

Console.WriteLine($"Parse time: {result.Diagnostics.ParseTimeMs}ms");
Console.WriteLine($"Token count: {result.Diagnostics.TokenCount}");
Console.WriteLine($"Errors: {result.Diagnostics.Errors.Count}");
Console.WriteLine($"Warnings: {result.Diagnostics.Warnings.Count}");

// Count all function calls in the code
public class CallCounter : GoAstWalker
{
    public int CallCount { get; private set; }
    
    public override void VisitCallExpression(CallExpression node)
    {
        CallCount++;
        base.VisitCallExpression(node);
    }
}

var counter = new CallCounter();
ast.Accept(counter);
Console.WriteLine($"Function calls: {counter.CallCount}");

// Export AST to JSON
var json = ast.ToJsonPretty();
File.WriteAllText("ast.json", json);

// Compact JSON for transmission
var compactJson = ast.ToJsonCompact();

// Custom parser options
var options = new ParserOptions
{
    EnableCaching = true,
    RunAnalyzer = true,
    ContinueOnError = false,
    ErrorRecoveryMode = ErrorRecoveryMode.Default
};

var parser = new IronGoParser(options);
var ast = parser.ParseSource(source);

// Find specific nodes
var mainFunc = ast.FindFunction("main");
var allCalls = ast.GetAllCalls();
var stringLiterals = ast.GetLiterals(LiteralKind.String);

// Check imports
if (ast.IsPackageImported("fmt"))
{
    Console.WriteLine("fmt package is imported");
}

// Find all functions
var functions = ast.GetFunctions();

// Find all method declarations
var methods = ast.GetMethods();

// Find all type declarations
var types = ast.GetTypes();

// Find specific function by name
var mainFunc = ast.FindFunction("main");

// Get all imported packages
var imports = ast.GetImportedPackages();

// Find all identifiers
var identifiers = ast.GetAllIdentifiers();

// Find all function calls
var calls = ast.GetAllCalls();

// Get literals by type
var strings = ast.GetLiterals(LiteralKind.String);
var numbers = ast.GetLiterals(LiteralKind.Int);

// Count total nodes
var nodeCount = ast.CountNodes();

// Caching is enabled by default
var parser = new IronGoParser();

// First parse - cache miss
var ast1 = parser.ParseSource(source);

// Second parse - cache hit (very fast)
var ast2 = parser.ParseSource(source);

// Get cache statistics
var stats = ParserCache.Default.GetStatistics();
Console.WriteLine($"Cache hit rate: {stats.HitRate:P}");

// Try parse pattern
if (IronGoParser.TryParse(source, out var ast, out var error))
{
    // Success - use ast
}
else
{
    Console.WriteLine($"Parse error: {error}");
}

// Exception-based parsing
try
{
    var ast = IronGoParser.Parse(source);
}
catch (ParseException ex)
{
    foreach (var error in ex.Errors)
    {
        Console.WriteLine($"{error.Line}:{error.Column}: {error.Message}");
    }
}

var options = new ParserOptions { RunAnalyzer = true };
var parser = new IronGoParser(options);
var result = parser.ParseSourceWithDiagnostics(source);

foreach (var warning in result.Diagnostics.Warnings)
{
    Console.WriteLine($"{warning.Level}: {warning.Message} at {warning.Position}");
}