Fis-MessageTransmission/src/interface/interface.ts

import { BehaviorSubject, Observable, Subject, Unsubscribable } from "rxjs"
import { RetransmissionService } from "../utils/retransmission.service"
import { WrappedMessage } from "../utils/message.ordering"
import { ActorInterface, ActorProfile } from "./actor.interface"

/* EVENT BUS */
export interface GeneralEvent {
    id: string,
    type: EventType,
    event: EventMessage,
    date: Date,
    transmission?: Transmission,
    adapters?: AdapterInterface[],
    message?: TransportMessage
}

/* MANAGEMENT */
export interface MessageTransmissionManagerInterface<T> extends ActorInterface<T> {
}

export interface AdapterManagerInterface<T> extends ActorInterface<T> {
}


/* TRANSMISSION COMPONENTS */
export interface MessageTransmissionInterface {
}

export interface MessageReceiverInterface extends MessageTransmissionInterface {
    getIncoming(): Observable<any>
}

export interface MessageTransmitterInterface extends MessageTransmissionInterface {
    emit(message: any): void
}

export interface MessageRequestResponseInterface extends MessageTransmissionInterface {
    send(message: any): Observable<any>
}

/* ADAPTER COMPONENTS */
export interface AdapterInterface {
    role: TransmissionRole
    transport: Transport
}

export interface TransmitterAdapterInterface extends AdapterInterface {
    emit(message: WrappedMessage): void
}

export interface ReceiverAdapterInterface extends AdapterInterface {
    subscribe(): Observable<any>
}


/* Utils */
export interface TransmissionProfile {
    id: string,
    name: string,
    dateCreated: Date
}

export interface TransmitterProfile extends TransmissionProfile {
}

export interface ReceiverProfile extends TransmissionProfile {
}

export interface RequestResponseProfile extends TransmissionProfile {
}

export interface TransportMessage {
    id: string,
    dateCreated: Date,
    transport: Transport,
    target?: string,
    payload: any
}

export interface FisMessage {
    header: {
        messageID: string,
        messageName: `NotificationMessage` | `ResponseMessage` | `RequestMessage`
    },
    data: any
}

export interface Transmission {
    clientId: string,
    transmitter: MessageTransmitterInterface,
    receiver: MessageReceiverInterface,
    requestResponse: MessageRequestResponseInterface,
    event: Observable<GeneralEvent>
}

export type Transport = 'Websocket' | 'Http' | 'TCP'

export enum AdapterTransmissionRole {
    Transmitter,
    Receiver,
    RequestResponse
}


export type EventType = `General Event` | 'Transport Event' | 'Transmission Event' | 'Adapter Event'
export type TransmissionRole = `Transmitter` | 'Receiver' | 'RequestResponse'
export type EventMessage = 'Server Started' | 'New Client' | 'Client Connected' | 'Client Re-connected' | 'Client Disconnected' | `Server Disconnected` | 'New Message' | `Notification` | `New Server` | `Server Connected` | `New Transport` | 'New Adapter' | 'Re-Flush' | 'New Transport' | 'New Transmission'
export type ConnectionState = 'ONLINE' | 'OFFLINE'
export interface TransportService {
    getInfo(): Transport
    emit(message: TransportMessage): void
    subscribe(): Observable<GeneralEvent> //all messages and whatever event will go through this, easier to implemnet across different transport protocol
}

export interface Info {
    transport: Transport
}

export interface ClientObject {
    id: string,
    dateCreated: Date,
    connectionState: BehaviorSubject<ConnectionState>
}


export interface AdapterProfile {
    id: string,
    transportType: Transport,
}

export interface TransportSet {
    transport: Transport,
    port: number
}

export interface TransportProfileMessage {
    clientId: string,
    message?: string,
    payload?: any
}