From d5f7201eb7b10826e77eccb33f9cca784261091f Mon Sep 17 00:00:00 2001
From: Mel <einebeere@gmail.com>
Date: Sat, 19 Feb 2022 19:46:36 +0100
Subject: Make connection an object and merge starts

---
 assets/src/network/channel/connection.ts | 150 +++++++++++++++++--------------
 1 file changed, 81 insertions(+), 69 deletions(-)

(limited to 'assets/src/network/channel/connection.ts')

diff --git a/assets/src/network/channel/connection.ts b/assets/src/network/channel/connection.ts
index 04ff6e8..8b49388 100644
--- a/assets/src/network/channel/connection.ts
+++ b/assets/src/network/channel/connection.ts
@@ -1,14 +1,18 @@
 import { Channel, Push, Socket } from "phoenix";
 import { get, Readable, writable, Writable } from "svelte/store";
+import { RookType } from "../../models/rook_type";
+import getShareToken from "../../utils/getShareToken";
+import type { AnyMessage } from "./messages/messages";
 import {
-    HandlerFn,
-    EventHandler,
-    registerHandlerForSpecificToken,
-    UnregisterFn,
-    registerHandler,
-} from "./messages/event_handler";
-import type { AnyMessage, TokenizedMessage } from "./messages/messages";
-import { connectSocket, fetchToken } from "./socket";
+    MessageHandler,
+    routeEventToHandler,
+} from "./messages/message_handler";
+import {
+    connectSocket,
+    fetchTokenFromSocket,
+    joinRequestChannel,
+    joinShareChannel,
+} from "./socket";
 
 export enum ConnectionState {
     CONNECTING_SOCKET,
@@ -18,81 +22,89 @@ export enum ConnectionState {
     CONNECTED,
 }
 
-export type Connection = {
+export class Connection {
     socket: Socket;
     channel: Channel | null;
     token: string | null;
     state: Writable<ConnectionState>;
-    handlers: EventHandler;
-};
-
-const connection: Connection = {
-    socket: new Socket("/socket", {}),
-    channel: null,
-    token: null,
-    state: writable(ConnectionState.CONNECTING_SOCKET),
-    handlers: {},
-};
 
-export async function start() {
-    await connectSocket(connection.socket);
+    handler: MessageHandler<AnyMessage>;
 
-    updateState(ConnectionState.FETCHING_TOKEN);
-    connection.token = await fetchToken(connection.socket);
-
-    return connection;
-}
+    constructor() {
+        this.socket = new Socket("/socket", {});
+        this.channel = null;
+        this.token = null;
+        this.state = writable(ConnectionState.CONNECTING_SOCKET);
+        this.handler = {};
+    }
 
-export function send(event: string, data: any): Push {
-    if (getState() !== ConnectionState.CONNECTED) {
-        throw new Error("There is no connection yet.");
+    async start(type: RookType) {
+        // Connect to server.
+        await connectSocket(this.socket);
+
+        // Fetch token for connection.
+        this.updateState(ConnectionState.FETCHING_TOKEN);
+        this.token = await fetchTokenFromSocket(this.socket);
+
+        // Connect to the correct channel.
+        this.updateState(ConnectionState.CONNECTING_CHANNEL);
+        switch (type) {
+            case RookType.REQUEST:
+                const requestChannel = await joinRequestChannel(
+                    this.socket,
+                    this.token,
+                    getShareToken()
+                );
+                this.channel = requestChannel;
+
+                break;
+            case RookType.SHARE:
+                const shareChannel = await joinShareChannel(
+                    this.socket,
+                    this.token
+                );
+                this.channel = shareChannel;
+
+                break;
+        }
+
+        this.updateState(ConnectionState.CONNECTED);
+
+        // Setup up event handler.
+        this.channel.onMessage = (event, payload) => {
+            console.log(event, payload);
+
+            const payloadWithEvent = { ...payload, event_name: event };
+            routeEventToHandler(event, payloadWithEvent, this.handler);
+            return payload;
+        };
     }
 
-    return connection.channel.push(event, data);
-}
+    send(event: string, data: any): Push {
+        if (get(this.getState()) !== ConnectionState.CONNECTED) {
+            throw new Error("There is no connection yet.");
+        }
 
-export function onWithToken<M extends TokenizedMessage>(
-    event: M["event_name"],
-    token: string | null,
-    handler: HandlerFn<M>
-): UnregisterFn {
-    return registerHandlerForSpecificToken(
-        connection.handlers,
-        connection.channel,
-        event,
-        token,
-        handler
-    );
-}
+        return this.channel.push(event, data);
+    }
 
-export function on<M extends AnyMessage>(
-    event: M["event_name"],
-    handler: HandlerFn<M>
-): UnregisterFn {
-    return registerHandler(
-        connection.handlers,
-        connection.channel,
-        event,
-        handler
-    );
-}
+    getOwnToken(): string {
+        if (get(this.getState()) <= ConnectionState.FETCHING_TOKEN) {
+            throw new Error("There is no token yet.");
+        }
 
-export function getOwnToken(): string {
-    if (getState() <= ConnectionState.FETCHING_TOKEN) {
-        throw new Error("There is no token yet.");
+        return this.token;
     }
 
-    return connection.token;
-}
-
-export function getState(): ConnectionState {
-    return get(connection.state);
-}
+    getState(): Writable<ConnectionState> {
+        return this.state;
+    }
 
-export function updateState(state: ConnectionState) {
-    connection.state.set(state);
-}
+    updateState(state: ConnectionState) {
+        this.state.set(state);
+    }
 
-export function getStateStore(): Readable<ConnectionState> {
-    return connection.state;
+    setChannelMessageHandler(handler: MessageHandler<AnyMessage>) {
+        this.handler = handler;
+    }
 }
-- 
cgit 1.4.1