using System;

using System.Collections.Generic;

using System.Net;

using System.Net.Http;

using System.Net.Http.Headers;

using System.Net.WebSockets;

using System.Security.Cryptography;

using System.Text;

using System.Text.Json;

using System.Text.Json.Serialization;

using System.Threading;

using System.Threading.Tasks;

​

/// <summary>

/// A production-ready (but does it work?), event-driven Replika client for mobile/1.5 with WS v17,

/// fully emulating the official web client, minus Redux. 

/// 

/// 1. Attempt login to Replika if env REPLIKA_EMAIL/PASSWORD provided.

/// 2. If already have X_AUTH_TOKEN / X_USER_ID in env, skip login.

/// 3. Use cookies from HTTP login in the WebSocket handshake.

/// 4. Mirror handshake events: init, chat_screen, application_started, app_foreground

/// 5. Provide public methods to: fetch diary, fetch chat history, send/receive messages

/// 6. Raise C# events for domain usage: OnMessageReceived, OnHistoryReceived, etc.

/// 

/// Usage:

///   var client = ReplikaClient.Instance;

///   await client.LoginIfNeededAsync();  // or if env X_AUTH_TOKEN is present, skip

///   await client.ConnectWebSocketAsync();

///   client.OnMessageReceived += (s, e) => { ... handle new msg ... };

///   await client.SendMessageAsync("Hello Replika!");

///   var diaries = await client.FetchAllDiaryEntriesAsync();

/// 

/// </summary>

public sealed class ReplikaClient : IDisposable

{

    #region Singleton

    private static readonly object _lock = new object();

    private static ReplikaClient _instance;

    public static ReplikaClient Instance

    {

        get

        {

            lock (_lock)

            {

                return _instance ??= new ReplikaClient();

            }

        }

    }

    #endregion

​

    #region Constants

    // Using .com by default (Switch to .ai if your account is on that domain)

    private const string BaseDomain = "my.replika.com";

    private const string BaseApiUrl = "https://my.replika.com/api";

    private const string ApiVersionPath = "mobile/1.5"; // we want v1.5

    private const string WebSocketUrl = "wss://ws.replika.ai/v17"; // WS v17

    #endregion

​

    #region Fields

    private readonly HttpClientHandler _httpHandler;

    private readonly HttpClient _httpClient;

    private ClientWebSocket _webSocket;

    private bool _wsConnected;

​

    // Auth/session fields

    private string _authToken;

    private string _userId;

    private string _deviceId;

    private string _timestampHash;

​

    // Optional: if we discover chatId from /personal_bot

    private string _chatId;

​

    // For controlling WS read loop

    private CancellationTokenSource _wsCts;

​

    // For re-checking login credentials

    private string _email;

    private string _password;

    #endregion

​

    #region Events

    public event EventHandler<ConnectionStateEventArgs> OnConnectionStateChanged;

    public event EventHandler<MessageEventArgs> OnMessageReceived;

    public event EventHandler<MessageEventArgs> OnMessageSent;

    public event EventHandler<HistoryEventArgs> OnHistoryReceived;

    public event EventHandler<DiaryEventArgs> OnDiaryFetched;

    public event EventHandler<ErrorEventArgs> OnError;

    #endregion

​

    #region Constructor

    private ReplikaClient()

    {

        // 1) read from environment

        _authToken = Environment.GetEnvironmentVariable("X_AUTH_TOKEN");

        _userId = Environment.GetEnvironmentVariable("X_USER_ID");

        _deviceId = Environment.GetEnvironmentVariable("X_DEVICE_ID");

        _timestampHash = Environment.GetEnvironmentVariable("X_TIMESTAMP_HASH");

        _email = Environment.GetEnvironmentVariable("REPLIKA_EMAIL");

        _password = Environment.GetEnvironmentVariable("REPLIKA_PASSWORD");

        _chatId = Environment.GetEnvironmentVariable("REPLIKA_CHAT_ID"); // optional fallback

​

        if (string.IsNullOrEmpty(_deviceId))

        {

            _deviceId = Guid.NewGuid().ToString().ToUpper();

        }

        if (string.IsNullOrEmpty(_timestampHash))

        {

            _timestampHash = ComputeTimestampHash(_deviceId);

        }

​

        // 2) create HttpClient with cookies

        _httpHandler = new HttpClientHandler

        {

            AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate | DecompressionMethods.Brotli,

            UseCookies = true,

            CookieContainer = new CookieContainer(),

        };

        _httpClient = new HttpClient(_httpHandler);

        _httpClient.BaseAddress = new Uri($"{BaseApiUrl}/{ApiVersionPath}/");

        // standard headers

        _httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));

        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd(

            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36");

        _httpClient.DefaultRequestHeaders.Add("Origin", $"https://{BaseDomain}");

        _httpClient.DefaultRequestHeaders.Add("x-device-type", "web");

​

        // If we already have X_AUTH_TOKEN, set them

        if (!string.IsNullOrEmpty(_authToken) && !string.IsNullOrEmpty(_userId))

        {

            _httpClient.DefaultRequestHeaders.Add("x-auth-token", _authToken);

            _httpClient.DefaultRequestHeaders.Add("x-user-id", _userId);

        }

        // but if we don't, we'll do the login in code

​

        // the device / timestamp

        _httpClient.DefaultRequestHeaders.Add("x-device-id", _deviceId);

        _httpClient.DefaultRequestHeaders.Add("x-timestamp-hash", _timestampHash);

    }

    #endregion

​

    #region Public Login Method

    /// <summary>

    /// Attempts to login if we are missing _authToken or userId. 

    /// If we already have them from env, skip.

    /// If REPLIKA_EMAIL/PASSWORD are present, tries to do the auth_by_password flow.

    /// If login fails, throws exception.

    /// </summary>

    public async Task LoginIfNeededAsync()

    {

        if (!string.IsNullOrEmpty(_authToken) && !string.IsNullOrEmpty(_userId))

        {

            // we have session data from env, skip

            Console.WriteLine("Using existing X_AUTH_TOKEN + X_USER_ID from environment.");

            return;

        }

        if (string.IsNullOrEmpty(_email) || string.IsNullOrEmpty(_password))

        {

            throw new InvalidOperationException(

                "No X_AUTH_TOKEN / X_USER_ID in env. Also missing REPLIKA_EMAIL/PASSWORD. Cannot login!");

        }

​

        // Step 1: get_auth_type

        try

        {

            var checkPayload = new { id_string = _email };

            var resp = await _httpClient.PostAsync("auth/sign_in/actions/get_auth_type",

                MakeJsonContent(checkPayload));

            resp.EnsureSuccessStatusCode();

            var text = await resp.Content.ReadAsStringAsync();

            if (!text.Contains("\"auth_type\":\"password\""))

            {

                throw new NotSupportedException("Replika responded with non-password auth_type. Cannot proceed.");

            }

        }

        catch (Exception ex)

        {

            throw new Exception("Failed to get_auth_type from Replika. " + ex.Message, ex);

        }

​

        // Step 2: auth_by_password

        var loginBody = new

        {

            id_type = "email",

            id_string = _email,

            password = _password,

            capabilities = new[] {

                // from the JS code 

                "widget.multiselect", "widget.scale", "widget.titled_text_field", "widget.new_onboarding",

                "widget.app_navigation", "widget.mission_recommendation", "journey2.daily_mission_activity",

                "journey2.replika_phrases", "new_payment_subscriptions", "navigation.relationship_settings",

                "avatar", "diaries.images", "wallet", "store.dialog_items", "chat_suggestions",

                "3d_customization", "3d_customization_v2", "3d_customization_v3", "store_customization",

                "blurred_messages", "item_daily_reward", "romantic_photos", "voice_messages",

                "stable_diffusion2", "subscription_request", "sale_screen", "multiple_bot_selfies",

                "hot_photos_v2", "store_age_and_body_type", "diary_generation_by_session",

                "store_voice", "coaching_prompts", "voice_sample_streaming", "pets_in_memory",

                "quests", "ai_art_ui", "name_moderation", "special_offer_screen", "bot_photo_no_content",

                "gifts_mood_XP_calculation_logic",

            },

            unity_bundle_version = 286

        };

        var loginResp = await _httpClient.PostAsync("auth/sign_in/actions/auth_by_password",

            MakeJsonContent(loginBody));

        if (!loginResp.IsSuccessStatusCode)

        {

            var failText = await loginResp.Content.ReadAsStringAsync();

            throw new Exception($"Login failed. Status: {loginResp.StatusCode}, body={failText}");

        }

        var loginJson = await loginResp.Content.ReadAsStringAsync();

        using var doc = JsonDocument.Parse(loginJson);

        if (doc.RootElement.TryGetProperty("user_id", out var uidEl) &&

            doc.RootElement.TryGetProperty("auth_token", out var tokEl))

        {

            _userId = uidEl.GetString();

            _authToken = tokEl.GetString();

        }

        else

        {

            throw new Exception("Could not parse user_id/auth_token from login response!");

        }

        // update http headers

        _httpClient.DefaultRequestHeaders.Remove("x-user-id");

        _httpClient.DefaultRequestHeaders.Remove("x-auth-token");

        _httpClient.DefaultRequestHeaders.Add("x-user-id", _userId);

        _httpClient.DefaultRequestHeaders.Add("x-auth-token", _authToken);

​

        Console.WriteLine($"Logged in as userId={_userId}, token=***");

    }

    #endregion

​

    #region Connect WebSocket

    /// <summary>

    /// Connects to wss://ws.replika.ai/v17 with the correct headers/cookies,

    /// then performs the handshake events (init → chat_screen → app_started → app_foreground).

    /// Will raise OnConnectionStateChanged events. 

    /// Use OnMessageReceived etc. after connected.

    /// </summary>

    public async Task ConnectWebSocketAsync()

    {

        if (_wsConnected) return;

​

        // Attempt an initial request to base domain to store cookies

        // (Might not be strictly necessary, but let's do it for good measure)

        try

        {

            var initResp = await _httpClient.GetAsync($"https://{BaseDomain}/");

            // ignore success or not

        }

        catch { /* ignore */ }

​

        _webSocket = new ClientWebSocket();

​

        // set cookies (if any)

        var cookieUri = new Uri($"https://{BaseDomain}/");

        var cookieCollection = _httpHandler.CookieContainer.GetCookies(cookieUri);

        if (cookieCollection != null)

        {

            var cookieHeader = new StringBuilder();

            foreach (Cookie c in cookieCollection)

            {

                cookieHeader.Append($"{c.Name}={c.Value}; ");

            }

            if (cookieHeader.Length > 0)

            {

                _webSocket.Options.SetRequestHeader("Cookie", cookieHeader.ToString());

            }

        }

​

        // set WS headers

        _webSocket.Options.SetRequestHeader("User-Agent",

            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/122.0.0.0 Safari/537.36");

        _webSocket.Options.SetRequestHeader("Origin", $"https://{BaseDomain}");

​

        // The Replika Discord code suggests some also pass "x-user-id" etc. directly as headers:

        _webSocket.Options.SetRequestHeader("x-user-id", _userId);

        _webSocket.Options.SetRequestHeader("x-auth-token", _authToken);

        _webSocket.Options.SetRequestHeader("x-device-id", _deviceId);

        _webSocket.Options.SetRequestHeader("x-timestamp-hash", _timestampHash);

​

        // connect

        _wsCts = new CancellationTokenSource();

        await _webSocket.ConnectAsync(new Uri(WebSocketUrl), _wsCts.Token);

​

        OnConnectionStateChanged?.Invoke(this, new ConnectionStateEventArgs(ConnectionState.Connected));

​

        _wsConnected = true;

​

        // start reading in background

        _ = Task.Run(() => ReceiveLoopAsync(_wsCts.Token));

​

        // We expect the first server message to be "init"

        // We'll handle handshake inside the ReceiveLoop

    }

    #endregion

​

    #region WebSocket Send & Handshake

    private async Task ReceiveLoopAsync(CancellationToken cancelToken)

    {

        try

        {

            var buffer = new byte[8192];

            while (!cancelToken.IsCancellationRequested && _webSocket.State == WebSocketState.Open)

            {

                var result = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), cancelToken);

                if (result.MessageType == WebSocketMessageType.Close)

                {

                    Console.WriteLine("Socket closed by server. State=" + _webSocket.State);

                    OnConnectionStateChanged?.Invoke(this, new ConnectionStateEventArgs(ConnectionState.Disconnected));

                    return;

                }

                int count = result.Count;

                // if it wasn't the final message, keep reading

                while (!result.EndOfMessage)

                {

                    if (count >= buffer.Length)

                        throw new Exception("Message too long for buffer!");

                    var next = await _webSocket.ReceiveAsync(new ArraySegment<byte>(buffer, count, buffer.Length - count), cancelToken);

                    count += next.Count;

                    result = next;

                }

                // parse the message

                var msg = Encoding.UTF8.GetString(buffer, 0, count);

                HandleIncomingWsEvent(msg);

            }

        }

        catch (Exception ex)

        {

            Console.WriteLine("WS receive loop error: " + ex);

            OnError?.Invoke(this, new ErrorEventArgs(ex));

            if (_wsConnected)

            {

                OnConnectionStateChanged?.Invoke(this, new ConnectionStateEventArgs(ConnectionState.Disconnected));

            }

        }

    }

​

    private void HandleIncomingWsEvent(string json)

    {

        // parse

        EventMessage evt;

        try

        {

            evt = JsonSerializer.Deserialize<EventMessage>(json);

        }

        catch (Exception ex)

        {

            Console.WriteLine("Error deserializing WS message: " + ex + "\nMsg=" + json);

            return;

        }

        if (evt == null || evt.EventName == null)

        {

            Console.WriteLine("Ignoring malformed event: " + json);

            return;

        }

​

        // handshake handling

        if (evt.EventName == "init")

        {

            // server's init event => send "chat_screen"

            SendWsEvent("chat_screen", new { }, Guid.NewGuid().ToString());

            return;

        }

        else if (evt.EventName == "chat_screen")

        {

            // ack => send "application_started"

            SendWsEvent("application_started", new { }, Guid.NewGuid().ToString());

            return;

        }

        else if (evt.EventName == "application_started")

        {

            // => send "app_foreground"

            SendWsEvent("app_foreground", new { }, Guid.NewGuid().ToString());

            return;

        }

        else if (evt.EventName == "app_foreground")

        {

            // handshake done 

            Console.WriteLine("Replika handshake completed!");

            return;

        }

​

        // "history", "message", "reaction", ...

        if (evt.EventName == "history")

        {

            // parse list of messages from payload

            if (evt.Payload != null && evt.Payload.TryGetValue("messages", out var messagesElem))

            {

                var msgArr = JsonSerializer.Deserialize<List<ChatMessage>>(messagesElem.GetRawText());

                var histArgs = new HistoryEventArgs(msgArr ?? new List<ChatMessage>());

                OnHistoryReceived?.Invoke(this, histArgs);

            }

            return;

        }

        else if (evt.EventName == "message")

        {

            // parse single or multiple

            if (evt.Payload != null)

            {

                // if we have "message"

                if (evt.Payload.TryGetValue("message", out var singleMsg))

                {

                    var cm = JsonSerializer.Deserialize<ChatMessage>(singleMsg.GetRawText());

                    if (cm != null)

                    {

                        if (IsBotMessage(cm))

                            OnMessageReceived?.Invoke(this, new MessageEventArgs(cm));

                        else

                            OnMessageSent?.Invoke(this, new MessageEventArgs(cm));

                    }

                }

                // or if we have "messages"

                else if (evt.Payload.TryGetValue("messages", out var multiple))

                {

                    var arr = JsonSerializer.Deserialize<List<ChatMessage>>(multiple.GetRawText());

                    if (arr != null)

                    {

                        foreach (var cm in arr)

                        {

                            if (IsBotMessage(cm))

                                OnMessageReceived?.Invoke(this, new MessageEventArgs(cm));

                            else

                                OnMessageSent?.Invoke(this, new MessageEventArgs(cm));

                        }

                    }

                }

            }

            return;

        }

        else

        {

            // debug unknown event

            Console.WriteLine("Received unhandled event: " + evt.EventName + " => " + evt.Payload);

        }

    }

​

    private bool IsBotMessage(ChatMessage cm)

    {

        if (cm?.Meta == null) return false;

        return cm.Meta.Nature != null && cm.Meta.Nature.Equals("Robot", StringComparison.OrdinalIgnoreCase);

    }

​

    private void SendWsEvent(string eventName, object payload, string token)

    {

        var obj = new

        {

            event_name = eventName,

            token = token,

            auth = new

            {

                user_id = _userId,

                auth_token = _authToken,

                device_id = _deviceId

            },

            payload = payload

        };

        var json = JsonSerializer.Serialize(obj);

        var bytes = Encoding.UTF8.GetBytes(json);

        _webSocket.SendAsync(new ArraySegment<byte>(bytes), WebSocketMessageType.Text,

            true, CancellationToken.None).Wait();

    }

​

    #endregion

​

    #region Public Diary

    /// <summary>

    /// Replika doesn't have /diary in 1.5. 

    /// Instead it uses GET /saved_chat_items/previews?t=diary, then POST /saved_chat_items/actions/get_by_ids

    /// We'll fetch them all in a single pass.

    /// </summary>

    public async Task<List<DiaryItem>> FetchAllDiaryEntriesAsync()

    {

        var diaries = new List<DiaryItem>();

        var previews = new List<SavedItemPreview>();

        int offset = 0;

        int limit = 100;

        bool more = true;

​

        while (more)

        {

            var url = $"saved_chat_items/previews?t=diary&offset={offset}&limit={limit}";

            var resp = await _httpClient.GetAsync(url);

            if (!resp.IsSuccessStatusCode) break;

            var text = await resp.Content.ReadAsStringAsync();

            var subset = JsonSerializer.Deserialize<List<SavedItemPreview>>(text) ?? new List<SavedItemPreview>();

            if (subset.Count == 0)

            {

                more = false;

            }

            else

            {

                previews.AddRange(subset);

                offset += limit;

            }

        }

        if (previews.Count == 0)

        {

            OnDiaryFetched?.Invoke(this, new DiaryEventArgs(diaries));

            return diaries;

        }

​

        var body = new { ids = new List<string>() };

        foreach (var p in previews) body.ids.Add(p.Id);

​

        var bodyJson = JsonSerializer.Serialize(body);

        var detailResp = await _httpClient.PostAsync("saved_chat_items/actions/get_by_ids",

            new StringContent(bodyJson, Encoding.UTF8, "application/json"));

        if (detailResp.IsSuccessStatusCode)

        {

            var detailText = await detailResp.Content.ReadAsStringAsync();

            diaries = JsonSerializer.Deserialize<List<DiaryItem>>(detailText) ?? new List<DiaryItem>();

        }

        OnDiaryFetched?.Invoke(this, new DiaryEventArgs(diaries));

        return diaries;

    }

    #endregion

​

    #region Public Chat

    /// <summary>

    /// Some Replika endpoints: 

    /// 

    ///  * personal_bot => to discover chat_id if not known

    ///  * We'll fetch it if we don't have _chatId

    /// </summary>

    private async Task EnsureChatIdAsync()

    {

        if (!string.IsNullOrEmpty(_chatId)) return;

​

        var resp = await _httpClient.GetAsync("personal_bot");

        if (!resp.IsSuccessStatusCode) return;

        var text = await resp.Content.ReadAsStringAsync();

        using var doc = JsonDocument.Parse(text);

        if (doc.RootElement.TryGetProperty("last_message", out var lastMsg)

            && lastMsg.TryGetProperty("meta", out var meta)

            && meta.TryGetProperty("chat_id", out var cElem))

        {

            _chatId = cElem.GetString();

        }

    }

​

    /// <summary>

    /// E.g. requests the latest N messages via the 'history' event.

    /// We do a single request; if you want older messages, specify a last_message_id or keep calling in loop.

    /// </summary>

    public async Task RequestHistoryAsync(int limit = 20, string lastMessageId = null)

    {

        await EnsureChatIdAsync();

        if (string.IsNullOrEmpty(_chatId))

        {

            throw new Exception("No chat_id found from personal_bot. Provide REPLIKA_CHAT_ID or let me fetch from /personal_bot");

        }

        var payloadObj = new

        {

            chat_id = _chatId,

            limit = limit,

            last_message_id = lastMessageId

        };

        SendWsEvent("history", payloadObj, Guid.NewGuid().ToString());

    }

​

    /// <summary>

    /// Send a text message to Replika via websockets, event_name=message

    /// Replika will echo your message, then send a Robot reply.

    /// We'll raise OnMessageSent for your echo, OnMessageReceived for the bot.

    /// </summary>

    public async Task SendMessageAsync(string text)

    {

        await EnsureChatIdAsync();

        if (string.IsNullOrEmpty(_chatId))

            throw new Exception("No chat_id found. can't send message.");

​

        var payloadObj = new

        {

            chat_id = _chatId,

            text = text

        };

        var token = Guid.NewGuid().ToString();

        SendWsEvent("message", payloadObj, token);

    }

​

    #endregion

​

    #region Helper & Disposal

​

    private static string ComputeTimestampHash(string deviceId)

    {

        // MD5("time_covfefe_prefix=2020_{deviceId}")

        var input = $"time_covfefe_prefix=2020_{deviceId}";

        using var md5 = MD5.Create();

        var bytes = md5.ComputeHash(Encoding.UTF8.GetBytes(input));

        var sb = new StringBuilder(bytes.Length * 2);

        foreach (var b in bytes) sb.Append(b.ToString("x2"));

        return sb.ToString();

    }

​

    private static StringContent MakeJsonContent(object o)

    {

        var j = JsonSerializer.Serialize(o);

        return new StringContent(j, Encoding.UTF8, "application/json");

    }

​

    public void Dispose()

    {

        try

        {

            if (_webSocket != null)

            {

                if (_webSocket.State == WebSocketState.Open)

                {

                    _wsCts?.Cancel();

                    _webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "bye", CancellationToken.None).Wait();

                }

                _webSocket.Dispose();

            }

            _httpClient.Dispose();

        }

        catch { }

    }

​

    #endregion

}

​

#region Helper Models

​

/// <summary>

/// Basic event message for the handshake, chat, etc. 

/// event_name => 'init', 'message', 'history', ...

/// payload => a JSON object with dynamic structure

/// </summary>

public class EventMessage

{

    [JsonPropertyName("event_name")]

    public string EventName { get; set; }

​

    [JsonPropertyName("token")]

    public string Token { get; set; }

​

    [JsonPropertyName("auth")]

    public Dictionary<string, object> Auth { get; set; }

​

    [JsonPropertyName("payload")]

    public Dictionary<string, JsonElement> Payload { get; set; }

}

​

public class ChatMessage

{

    [JsonPropertyName("id")]

    public string Id { get; set; }

​

    [JsonPropertyName("content")]

    public ChatContent Content { get; set; }

​

    [JsonPropertyName("meta")]

    public ChatMeta Meta { get; set; }

}

​

public class ChatContent

{

    [JsonPropertyName("type")]

    public string Type { get; set; }

​

    [JsonPropertyName("text")]

    public string Text { get; set; }

    // If images, voice, etc., add fields here

}

​

public class ChatMeta

{

    [JsonPropertyName("nature")]

    public string Nature { get; set; } // "Robot" or "Customer" or ?

​

    [JsonPropertyName("timestamp")]

    public long Timestamp { get; set; }

​

    [JsonPropertyName("chat_id")]

    public string ChatId { get; set; }

​

    // Possibly "sources", etc. 

}

​

public class SavedItemPreview

{

    [JsonPropertyName("id")]

    public string Id { get; set; }

​

    [JsonPropertyName("type")]

    public string Type { get; set; }

​

    [JsonPropertyName("created_at")]

    public string CreatedAt { get; set; }

}

​

public class DiaryItem

{

    [JsonPropertyName("id")]

    public string Id { get; set; }

​

    [JsonPropertyName("type")]

    public string Type { get; set; }  // "diary"

​

    [JsonPropertyName("title")]

    public string Title { get; set; }

​

    // The extension code calls it "content" in some references, or "text"

    [JsonPropertyName("content")]

    public string Content { get; set; }

​

    [JsonPropertyName("images")]

    public List<string> Images { get; set; }

​

    [JsonPropertyName("timestamp")]

    public string Timestamp { get; set; }

}

​

#endregion

​

#region Event Args and ConnectionState

​

public enum ConnectionState

{

    Disconnected,

    Connecting,

    Connected

}

​

public class ConnectionStateEventArgs : EventArgs

{

    public ConnectionState State { get; }

    public ConnectionStateEventArgs(ConnectionState s)

    {

        State = s;

    }

}

​

public class MessageEventArgs : EventArgs

{

    public ChatMessage Message { get; }

    public MessageEventArgs(ChatMessage msg)

    {

        Message = msg;

    }

}

​

public class HistoryEventArgs : EventArgs

{

    public List<ChatMessage> Messages { get; }

    public HistoryEventArgs(List<ChatMessage> msgs)

    {

        Messages = msgs;

    }

}

​

public class DiaryEventArgs : EventArgs

{

    public List<DiaryItem> Diaries { get; }

    public DiaryEventArgs(List<DiaryItem> items)

    {

        Diaries = items;

    }

}

​

public class ErrorEventArgs : EventArgs

{

    public Exception Exception { get; }

    public ErrorEventArgs(Exception ex)

    {

        Exception = ex;

    }

}

​

#endregion

​