EonaCat.JASP/README.md

# EonaCat.JASP Network Library

### Basic TCP Server

```csharp
using EonaCat.JASP;

var server = new NetworkServer(ProtocolType.TCP, 5000);

server.DataReceived += (s, e) =>
{
    var message = Encoding.UTF8.GetString(e.Data);
    Console.WriteLine($"Received: {message}");
};

server.Start();
```

### Basic TCP Client

```csharp
var client = new NetworkClient(ProtocolType.TCP, "127.0.0.1", 5000);

client.DataReceived += (s, e) =>
{
    var message = Encoding.UTF8.GetString(e.Data);
    Console.WriteLine($"Received: {message}");
};

await client.ConnectAsync();
client.SendString("Hello, Server!");
```

## Advanced

### Server with Authentication

```csharp
var server = new NetworkServer(
    ProtocolType.TCP,
    5000,
    username: "ServerAdmin",
    password: "SecurePassword123"
);

server.ClientConnected += (s, e) =>
{
    Console.WriteLine($"Authenticated client: {e.Username}");
};

server.Start();
```

### Client with Authentication

```csharp
var client = new NetworkClient(
    ProtocolType.TCP,
    "127.0.0.1",
    5000,
    username: "Alice",
    password: "SecurePassword123"
);

await client.ConnectAsync();
```

### Server with AES Encryption

```csharp
var server = new NetworkServer(
    ProtocolType.TCP,
    5000,
    useAES: true
);

server.Start();
```

### Client with AES Encryption

```csharp
var client = new NetworkClient(
    ProtocolType.TCP,
    "127.0.0.1",
    5000,
    useAES: true
);

await client.ConnectAsync();
```

### UDP Server/Client

```csharp
// Server
var server = new NetworkServer(ProtocolType.UDP, 5000);
server.Start();

// Client
var client = new NetworkClient(ProtocolType.UDP, "127.0.0.1", 5000);
await client.ConnectAsync();
```

### Client-to-Client Messaging

```csharp
// On Client 1 (Alice)
alice.SendToClient("Bob", "Hi Bob!");

// On Client 2 (Bob)
bob.DataReceived += (s, e) =>
{
    if (e.FromUsername == "Alice")
    {
        Console.WriteLine($"Message from Alice: {Encoding.UTF8.GetString(e.Data)}");
    }
};
```

### Broadcasting to All Clients

```csharp
// Server broadcasts to all connected clients
server.BroadcastString("Server announcement!");

// Broadcast to all except one client
server.BroadcastString("Message", excludeUsername: "Alice");
```

### Send Binary Data

```csharp
// Send byte array
byte[] imageData = File.ReadAllBytes("image.jpg");
client.SendData(imageData);

// Send to specific client
client.SendToClient("Bob", imageData);
```

### Network Statistics

```csharp
// Get server stats
var serverStats = server.GetStats();
Console.WriteLine(serverStats);
// Output:
// Stats:
//   Uptime: 00:05:23
//   Messages Sent: 15,234
//   Messages Received: 15,234
//   Bytes Sent: 1,523,400
//   Bytes Received: 1,523,400
//   Active Connections: 5
//   Messages/sec: 47.23
//   Errors: 0

// Get client stats
var clientStats = client.GetStats();
Console.WriteLine(clientStats);
```

### Get Connected Clients

```csharp
var clients = server.GetConnectedClients();
foreach (var client in clients)
{
    Console.WriteLine($"{client.Username} - {client.RemoteEndPoint}");
}
```

## Event Handlers

### Server Events

```csharp
server.DataReceived += (s, e) =>
{
    // Handle received data
    Console.WriteLine($"From: {e.FromUsername}");
    Console.WriteLine($"Data: {Encoding.UTF8.GetString(e.Data)}");
};

server.ClientConnected += (s, e) =>
{
    Console.WriteLine($"Client connected: {e.Username} ({e.ClientId})");
};

server.ClientDisconnected += (s, e) =>
{
    Console.WriteLine($"Client disconnected: {e.Username}");
};

server.ErrorOccurred += (s, e) =>
{
    Console.WriteLine($"Error: {e.Message}");
    Console.WriteLine($"Exception: {e.Exception}");
};
```

### Client Events

```csharp
client.DataReceived += (s, e) =>
{
    // Handle received data
};

client.Connected += (s, e) =>
{
    Console.WriteLine("Connected to server");
};

client.Disconnected += (s, e) =>
{
    Console.WriteLine("Disconnected from server");
};

client.ErrorOccurred += (s, e) =>
{
    Console.WriteLine($"Error: {e.Message}");
};
```