Fis-MessageTransmission/src/adapters/adapter.transmitter.ts

import dotenv from 'dotenv';
import { BehaviorSubject, distinctUntilChanged, filter, map, Observable, Subject } from 'rxjs';
import { WrappedMessage } from '../utils/message.ordering';
import ConsoleLogger from '../utils/log.utils';
import { AdapterBase } from '../base/adapter.base';
import { ClientObject, ConnectionState, FisMessage, TransportType, TransportMessage, TransportServiceInterface } from '../interface/interface';
import { fileURLToPath } from 'url';

dotenv.config();
/* This transport manager will be instantiating the necessary transport to deal with tranmission and receiving from different receivers
So how?: */
export class TransmitterAdapter extends AdapterBase {
    private console!: ConsoleLogger

    constructor(clientId: string, adapterType: TransportType, transportService: TransportServiceInterface) {
        super()
        this.console = new ConsoleLogger(`${adapterType}TransmitterAdapter`, ['adapter'])
        this.setAdapterProfile(clientId, adapterType, transportService, 'Transmitter')
        this.setupConnectionState(transportService)


        this.console.log({ message: `Contructing TransmitterAdapter for client: ${clientId}` })
    }

    emit(selfId: string, message: WrappedMessage): void {
        // logic here
        this.console.log({ message: `Emitting: ${(message.payload as FisMessage).header.messageID} to ${this.AdapterProfile.clientId}` })
        this.AdapterProfile.transportService.emit({
            id: this.AdapterProfile.clientId,
            self: selfId,
            target: this.AdapterProfile.clientId,
            payload: message
        } as TransportMessage)
    }

    getConnectionState(): Observable<ConnectionState> {
        return this.AdapterProfile.connectionState.asObservable()
    }

    private setupConnectionState(transportService: TransportServiceInterface): void {
        transportService.subscribeForEvent().pipe(
            filter(event => event.type === `Transport Event`),
            filter(event => (event.data as ClientObject).clientId === this.AdapterProfile.clientId),
            map(event => {
                if (event.event == 'Client Disconnected' || event.event == 'Server Disconnected') {
                    return 'OFFLINE'
                } else {
                    return `ONLINE`
                }
            }),
            distinctUntilChanged()
        ).subscribe((signal: ConnectionState) => {
            this.AdapterProfile.connectionState.next(signal)
            if (signal == 'OFFLINE') this.console.error({ message: `${this.AdapterProfile.clientId} disconnected` })
            if (signal == 'ONLINE') this.console.log({ message: `${this.AdapterProfile.clientId} connected and ready to go` })
        })
    }

}