ControlSpace

using ControlSpace.Core;
using ControlSpace.Languages;

var result = ProjectCompiler.Compile(DemoProject.Create());
foreach (var d in result.Diagnostics)
    Console.WriteLine($"{d.Severity} {d.Code} at {d.Location}:{d.Line}:{d.Column} {d.Message}");

if (result.Success)
{
    CompiledProgram program = result.Program!;
    Console.WriteLine($"{program.Blocks.Count} blocks, {program.Symbols.Count} tag slots");
}

// Token-aware SCL rename: comments and longer names are left alone.
string scl = SclParser.RenameSymbol("\"Motor_Run\" := TRUE; // Motor_Run_Old", "Motor_Run", "Conveyor_Run");

using ControlSpace.Core;
using ControlSpace.Languages;
using ControlSpace.Simulation;

var compilation = ProjectCompiler.Compile(DemoProject.Create());
if (!compilation.Success)
    throw new InvalidOperationException(string.Join("\n", compilation.Diagnostics));

var plc = new VirtualPlc(compilation.Program!);
plc.SetInput("Start_PB", 1);
plc.Run();
plc.Step(TimeSpan.FromMilliseconds(100));
Console.WriteLine(plc.Read("Motor_Run"));   // 1 in the sample simulation

plc.Force("Stop_PB", 1);                     // virtual forcing, never real I/O
plc.Step(TimeSpan.FromMilliseconds(100));
Console.WriteLine($"{plc.State}, cycle {plc.Cycle}, {plc.Trace.Count} trace samples");
plc.ReleaseAll();
plc.Stop();

using ControlSpace.Core;
using ControlSpace.Storage;

var project = DemoProject.Create();

string json = ProjectStorage.Serialize(project);          // versioned camelCase JSON
ControlProject loaded = ProjectStorage.Deserialize(json);  // limits, duplicate keys, validation
await ProjectStorage.SaveAtomicAsync("Conveyor_Line.json", loaded);

string csv = ProjectStorage.ExportTagsCsv(project.Tags);
IReadOnlyList<PlcTag> tags = ProjectStorage.ImportTagsCsv(csv);

using ControlSpace.Core;
using ControlSpace.Engineering;

var workspace = new Workspace(DemoProject.Create());
workspace.Changed += (_, _) => Console.WriteLine($"rev {workspace.Project.Revision}, dirty {workspace.IsDirty}");

// Validated transactions with undo/redo; references follow the rename.
workspace.RenameTag("Motor_Run", "Conveyor_Run");
new TagTableEditor(workspace).Add(PlcType.Int);
var blocks = new ProgramEditor(workspace);
string id = blocks.AddBlock(workspace.Project, "Diagnostics", BlockLanguage.SCL);
workspace.Undo();

foreach (var reference in workspace.CrossReferences("Conveyor_Run"))
    Console.WriteLine($"{reference.Block}/{reference.Network} {(reference.Write ? "write" : "read")}");

var result = workspace.Compile();   // creates workspace.Controller on success

using ControlSpace.Core;
using ControlSpace.Rendering.Skia;
using SkiaSharp;

var project = DemoProject.Create();
var main = project.Blocks.First(b => b.Name == "Main");

using var renderer = new EngineeringRenderer();
using var surface = SKSurface.Create(new SKImageInfo(1200, 800));
RenderResult result = renderer.Ladder(surface.Canvas, 1200, 800, main, project.Tags, snapshot: null);

foreach (HitRegion hit in result.Hits)
    Console.WriteLine($"{hit.Kind} {hit.Id} at {hit.Bounds}");

using var png = surface.Snapshot().Encode(SKEncodedImageFormat.Png, 100);
File.WriteAllBytes("main-ladder.png", png.ToArray());

using ControlSpace.Controls.Uno;
using ControlSpace.Core;
using ControlSpace.Engineering;
using Microsoft.UI.Xaml;
using Microsoft.UI.Xaml.Controls;

var workspace = new Workspace(DemoProject.Create());
var canvas = new EngineeringCanvas { Project = workspace.Project, Mode = EditorMode.Ladder, BlockId = "main" };
var tags = new EngineeringTable();
tags.Bind(workspace);                       // inline edits become undoable transactions
workspace.Changed += (_, _) => { canvas.Project = workspace.Project; canvas.Invalidate(); };

var layout = new Grid();
layout.RowDefinitions.Add(new RowDefinition { Height = new GridLength(2, GridUnitType.Star) });
layout.RowDefinitions.Add(new RowDefinition { Height = new GridLength(1, GridUnitType.Star) });
layout.Children.Add(new EngineeringViewport(canvas));
Grid.SetRow(tags, 1);
layout.Children.Add(tags);

var window = new Window { Title = "Ladder", Content = layout };
window.Activate();

using ControlSpace.Workbench.Uno;
using Microsoft.UI.Xaml;

sealed class MemoryProjectFiles : IProjectFiles
{
    private string? _recovery;
    public Task<string?> OpenAsync() => Task.FromResult<string?>(null);   // show a file picker here
    public Task<bool> SaveAsync(string contents, string name, string extension = ".json") => Task.FromResult(true);
    public Task<string?> ReadRecoveryAsync() => Task.FromResult(_recovery);
    public Task WriteRecoveryAsync(string contents) { _recovery = contents; return Task.CompletedTask; }
}

// In Application.OnLaunched:
var window = new Window { Title = "ControlSpace" };
var workbench = new WorkbenchView(new MemoryProjectFiles());
window.Content = workbench;
window.Activate();
await workbench.InitializeAsync();
window.Closed += (_, _) => workbench.Dispose();