Chatto/chatto/src/main/javascript/ts/src/model/ChatModel.ts

import { Subject } from "../observe/Observable";
import { Model } from "./AbstractModel";
import { Observer } from "../observe/Observer";
import { fetchErrorHandler } from "./FetchErrorHandler";
import { ActiveUserViewModel } from "../viewmodel/ActiveUserViewModel";
import { ChatMessageViewModel } from "../viewmodel/ChatMessageViewModel";
import { JsonAPI } from "../singleton/JsonAPI";
import log = require('loglevel');
import { EncryptionService } from "../service/EncryptionService";
import { SJCLEncryptionService } from "../service/SJCLEncryptionService";
import { ChatMessageDTO } from "../dto/ChatMessageDTO";
import { ChatModelHelper } from "./ChatModelHelper";

export class ChatModel implements Subject {
    /**
  * @type {Observer[]} List of subscribers. In real life, the list of
  * subscribers can be stored more comprehensively (categorized by event
  * type, etc.).
  */
    private readonly _observers: Observer[] = [];
    private state: ChatMessageViewModel[] | null;
    private readonly _messagePageMap: Map<string, number>;
    private readonly _messagesMap: Map<string, ChatMessageViewModel[]>;

    constructor() {
        this.state = null;
        this._messagePageMap = new Map();
        this._messagesMap = new Map();
    }
    /**
     * The subscription management methods.
     */
    public attach(observer: Observer): void {
        console.log('Subject: Attached an observer.');
        this._observers.push(observer);
    }

    public detach(observer: Observer): void {
        const observerIndex = this._observers.indexOf(observer);
        this._observers.splice(observerIndex, 1);
        console.log('Subject: Detached an observer.');
    }

    private storeUserMessages(username: string, messages: ChatMessageViewModel[]) {
        this._messagesMap.set(username, messages);
    }

    private getStoredUserMessages(username: string): ChatMessageViewModel[] {
        return this._messagesMap.get(username)!;
    }

    /**
     * Trigger an update in each subscriber.
     */
    public notify(userName: string): void {
        console.log('Subject: Notifying observers...');
        for (const observer of this._observers) {
            observer.update(this._messagesMap.get(userName));
        }
    }

    public someBusinessMethod(chatMessageList: ChatMessageViewModel[]): void {
        this.state = chatMessageList;
        console.log(`Subject: My state has just changed`);
        console.log(chatMessageList);
        this.notify("some user");
    }

    public async getMessages(contactName: string, passphrase: string, lastMessageTime: string | null): Promise<ChatMessageViewModel[]> {
        if(this._messagePageMap.get(contactName) == null)
            this._messagePageMap.set(contactName, 0);
        else {
            log.debug('page number before = ' + this._messagePageMap.get(contactName)!)
            this._messagePageMap.set(contactName, this._messagePageMap.get(contactName)! + 1);
            log.debug('page number after = ' + this._messagePageMap.get(contactName)!)
        }
        const pageNumber =  this._messagePageMap.get(contactName)
        const cVMs = await ChatModelHelper.getMessages(contactName, passphrase, pageNumber!, lastMessageTime, this);
        if (cVMs != null) {
            log.info('Subject: My state has just changed')
            
            // this._messagesMap.set(userName, cVMs);
            const existingMessages = this.getStoredUserMessages(contactName);
            log.debug(existingMessages);
            log.debug(cVMs);
            if (existingMessages != null) {
                // existingMessages.forEach(function (elem) {
                //     cVMs.push(elem);
                // })
                const newArr = cVMs.concat(existingMessages)
                // log.debug(newArr);
                this.storeUserMessages(contactName, cVMs);
                // this.storeUserMessages(contactName, cVMs);
            }
            else {
                this.storeUserMessages(contactName, cVMs);
            }
            JsonAPI.contactName = contactName;
            this.notify(contactName);
        }
        else {
            log.error('Messages were null');
        }

        return cVMs;
    }
}