# Install required tools
cargo xtask ffi install

# Build the native library
cargo xtask ffi build

# Or for release builds
cargo xtask ffi build --release

# Generate bindings
cargo xtask ffi bindings

dotnet add package Devolutions.IronRdp

using Devolutions.IronRdp;

// Create configuration
var config = new Config(
    username: "user",
    password: "password",
    domain: "DOMAIN",
    desktopWidth: 1920,
    desktopHeight: 1080
);

// Create connector
var connector = new ClientConnector(config, "127.0.0.1:54321");

// Attach static channels
connector.WithStaticChannelRdpSnd();
connector.WithStaticChannelRdpdr("COMPUTER", smartCardDeviceId: 0);

// Configure dynamic channels
connector.WithDynamicChannelDisplayControl();
connector.WithDynamicChannelPipeProxy(proxyConfig);

// Perform connection sequence
var state = connector.GetDynState();
while (!state.IsTerminal())
{
    var writeBuf = new WriteBuf();
    var written = connector.Step(inputData, writeBuf);
    
    // Handle security upgrade if needed
    if (connector.ShouldPerformSecurityUpgrade())
    {
        // Perform TLS handshake
        connector.MarkSecurityUpgradeAsDone();
    }
    
    // Handle CredSSP if needed
    if (connector.ShouldPerformCredssp())
    {
        // Perform NLA authentication
        connector.MarkCredsspAsDone();
    }
    
    state = connector.GetDynState();
}

// Get connection result
var result = connector.ConsumeAndCastToClientConnectorState();

var config = new Config(
    username: "user",
    password: "password",
    domain: null,  // Optional
    desktopWidth: 1920,
    desktopHeight: 1080
);

// Additional configuration
config.EnableTls = true;
config.EnableCredssp = true;
config.KeyboardType = KeyboardType.IbmEnhanced;
config.EnableAudioPlayback = false;

// Create from connection result
var activeStage = new ActiveStage(connectionResult);

// Process incoming RDP frames
var image = new DecodedImage(PixelFormat.RgbA32, width, height);
var outputs = activeStage.Process(image, action, payload);

// Handle outputs
foreach (var output in outputs)
{
    switch (output.GetEnumType())
    {
        case ActiveStageOutputType.ResponseFrame:
            var frame = output.GetResponseFrame();
            // Send frame to server
            break;
            
        case ActiveStageOutputType.GraphicsUpdate:
            var rect = output.GetGraphicsUpdate();
            // Update display region
            break;
            
        case ActiveStageOutputType.PointerBitmap:
            var pointer = output.GetPointerBitmap();
            // Update cursor image
            break;
            
        case ActiveStageOutputType.Terminate:
            var reason = output.GetTerminate();
            // Handle disconnection
            break;
    }
}

// Create input events
var events = new FastPathInputEventIterator();
events.Add(FastPathInputEvent.KeyPressed(scancode));
events.Add(FastPathInputEvent.MouseMove(x, y));
events.Add(FastPathInputEvent.MouseButtonPressed(button));

// Process input
var outputs = activeStage.ProcessFastpathInput(image, events);

// Create image buffer
var image = new DecodedImage(
    PixelFormat.RgbA32,
    width: 1920,
    height: 1080
);

// Access pixel data
var data = image.GetData();
var stride = image.GetStride();

// Copy region to display buffer
var region = output.GetGraphicsUpdate();
// Use data[region.Top * stride + region.Left] to access pixels

var pointer = output.GetPointerBitmap();

var width = pointer.GetWidth();
var height = pointer.GetHeight();
var hotspotX = pointer.GetHotspotX();
var hotspotY = pointer.GetHotspotY();
var data = pointer.GetData(); // RGBA pixel data

// Create clipboard backend
var backend = new YourClipboardBackend();
var cliprdr = new Cliprdr(backend);

// Attach to connector
connector.AttachStaticCliprdr(cliprdr);

// Later in active stage:
// Initiate copy from local to remote
var formats = new ClipboardFormatIterator();
formats.Add(ClipboardFormat.UnicodeText);
formats.Add(ClipboardFormat.Html);
var frame = activeStage.InitiateClipboardCopy(formats);

// Initiate paste from remote to local
var formatId = new ClipboardFormatId(ClipboardFormatId.CF_UNICODETEXT);
var frame = activeStage.InitiateClipboardPaste(formatId);

// Submit format data response
var response = new FormatDataResponse(data);
var frame = activeStage.SubmitClipboardFormatData(response);

// Enable during connection
connector.WithDynamicChannelDisplayControl();

// Later, request resize
var outputs = activeStage.EncodedResize(width: 2560, height: 1440);

var config = new DvcPipeProxyConfig();
config.AddDescriptor(new DvcPipeProxyDescriptor
{
    ChannelName = "custom-dvc",
    PipeName = @"\\.\pipe\my-pipe"
});

connector.WithDynamicChannelPipeProxy(config);

// Receive messages
messageSink.OnMessage((channelId, data) => {
    // Handle DVC message
});

// Send messages
var message = new DvcPipeProxyMessage(channelId, data);
var frame = activeStage.SendDvcPipeProxyMessage(message);

try
{
    var connector = new ClientConnector(config, clientAddr);
}
catch (IronRdpException ex)
{
    Console.WriteLine($"Error: {ex.Message}");
    Console.WriteLine($"Kind: {ex.Kind}");
}

public enum IronRdpErrorKind
{
    Generic,
    PduError,
    EncodeError,
    DecodeError,
    CredsspError,
    Consumed,
    IO,
    AccessDenied,
    IncorrectEnumType,
    Clipboard,
    WrongOS
}

// Determine action from incoming data
var action = Action.FromBytes(data);

// Allocate output buffer
var writeBuf = new WriteBuf();

// Process with action
var written = connector.Step(data, writeBuf);

// Get encoded output
var outputData = writeBuf.GetData();

var hint = connector.NextPduHint();
if (hint != null)
{
    var sizeResult = hint.FindSize(incomingBytes);
    if (sizeResult.HasValue)
    {
        var frameSize = sizeResult.Value;
        // Read exactly frameSize bytes
    }
}

// Optional values
public class OptionalUsize
{
    public bool HasValue { get; }
    public usize Value { get; }
}

// Positions
public struct Position
{
    public ushort X { get; set; }
    public ushort Y { get; set; }
}

// Rectangles
public struct InclusiveRectangle
{
    public ushort Left { get; set; }
    public ushort Top { get; set; }
    public ushort Right { get; set; }
    public ushort Bottom { get; set; }
}

// Byte slices
public class BytesSlice
{
    public byte[] GetData();
}

// Byte vectors
public class VecU8
{
    public byte[] GetData();
}

#if WINDOWS
var backend = new WinCliprdrBackend();
var cliprdr = new Cliprdr(backend);
connector.AttachStaticCliprdr(cliprdr);
#endif

cd ffi/dotnet
dotnet run --project Devolutions.IronRdp.ConnectExample

cd ffi/dotnet
dotnet run --project Devolutions.IronRdp.AvaloniaExample

// This consumes the connector
var state = connector.ConsumeAndCastToClientConnectorState();

// connector is now invalid - don't use it again

namespace = "Devolutions.IronRdp"
native_lib = "DevolutionsIronRdp"

[exceptions]
trim_suffix = "Error"
error_message_method = "ToDisplay"

[properties]
setters_prefix = "set_"
getters_prefix = "get_"

// Wrong - output might not be ResponseFrame
var frame = output.GetResponseFrame(); // Throws if wrong type

// Right - check type first
if (output.GetEnumType() == ActiveStageOutputType.ResponseFrame)
{
    var frame = output.GetResponseFrame(); // Safe
}