import { IAnyEventHandler, IClassroomEventHandler, LSAClient } from '@lenovo-software/lsa-clients-common';
import * as EventModels from '@lenovo-software/lsa-clients-common/dist/models/eventModels';
import { WebViewDispatcher } from './webViewDispatcher';
import { ChatMessage, RaiseHandStatusMessage } from '@lenovo-software/lsa-clients-common/dist/models/chat';
import { Logger } from '../common/logger';
import { Executor } from './executor';
import { ScreenshotCaptureService } from './screenshotCaptureService';
import { ScreenCaptureResponse } from './screenCapture';

export class AnyEventHandler implements IAnyEventHandler {
    onEvent(type: string, data: any) {
        console.log('GOT EVENT: ', type, ' data: ' + JSON.stringify(data));
    }
}

export interface IClassStatusEventSubscriber {
    onJoinClass(data: EventModels.JoinClassEventModel): void;
    onLeaveClass(data: EventModels.LeaveClassEventModel): void;
    onOrgVerification(isVerified: boolean): void;
}

export class ClassroomEventHandler implements IClassroomEventHandler {
    private classStatusEventSubscribers = new Array<IClassStatusEventSubscriber>();
    private logger = Logger.getInstance();
    private executor: Executor;

    constructor(private dispatcher: WebViewDispatcher, private screenShotCaptureService: ScreenshotCaptureService) {
        chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
            switch (request.message) {
                case 'SendChatMessage':
                    // From Angular window
                    LSAClient.getInstance().logger.logMessage('Got SendChatMessage: ' + JSON.stringify(request.data));
                    const chatMessage = new ChatMessage();
                    chatMessage.message = request.data.msg;
                    chatMessage.timestamp = request.data.timestamp;
                    LSAClient.getInstance().clientChat.postChatMessageToTeacher(chatMessage);
                    break;
                case 'RaiseHand':
                    // From Angular window
                    LSAClient.getInstance().logger.logMessage('Got RaiseHandMessage: ' + JSON.stringify(request.data));
                    const raiseHandMessage = new RaiseHandStatusMessage();
                    raiseHandMessage.timestamp = request.data.timestamp;
                    raiseHandMessage.handRaised = request.data.state;
                    LSAClient.getInstance().clientChat.postRaiseHandStatusToTeacher(raiseHandMessage);
                    break;
            }
        });

        this.executor = new Executor();
    }

    public onActiveInstructorsInfo(activeInstructorsModel: EventModels.ActiveInstructorsModel) {
        this.setState({
            activeInstructors: activeInstructorsModel.activeInstructors
        });
    }

    private setState(obj: any): void {
        this.dispatcher.sendToWebView(
            {
                message: 'UI_SetState',
                state: obj
            },
            false
        );
    }

    private chatMessage(obj: any): void {
        this.dispatcher.sendToWebView({ message: 'UI_ChatMessage', ...obj }, true);
    }

    public addSubscriber(sub: IClassStatusEventSubscriber) {
        this.classStatusEventSubscribers.push(sub);
    }

    public onPayloadVerificationFailure() {
        //throw new Error('Method not implemented.');
    }

    public onJoinClass(data: EventModels.JoinClassEventModel) {
        //throw new Error('Method not implemented.');
    }

    public onJoinClassPostProcess(currentClassData: EventModels.JoinClassEventModel) {
        this.setState({
            className: currentClassData.className
        });
        this.classStatusEventSubscribers.forEach((sub) => {
            sub.onJoinClass(currentClassData);
        });
    }

    public onLeaveClass(data: EventModels.LeaveClassEventModel) {
        this.setState({
            className: ''
        });

        this.classStatusEventSubscribers.forEach((sub) => {
            sub.onLeaveClass(data);
        });

        // Stop Thumbnail capture on leaving the class
        chrome.runtime.sendMessage({
            message: 'StopThumbnailCapture'
        });
    }

    public onLeaveClassPostProcess(data: EventModels.LeaveClassEventModel) {
        this.onLeaveClass(data);
    }

    public onPublicKeyReceivedFromTeacher(data: any) {
        //throw new Error('Method not implemented.');
    }

    public onTelemetryRequest(data: EventModels.TelemetryRequestEventModel) {
        //throw new Error('Method not implemented.');
    }

    public onLimitState(data: EventModels.LimitingRequestEventModel) {
        //throw new Error('Method not implemented.');
    }

    private isValidShellExecutePath(path: string): boolean {
        let url;

        try {
            url = new URL(path);
        } catch (e) {
            return false;
        }

        return url.protocol.match(/https?:/) ? true : false;
    }

    public onRemoteExecute(data: EventModels.RemoteExecuteEventModel) {
        this.logger.logMessage('ClassroomEventHandler onRemoteExecute!');
        this.executor.execute(data);
    }

    public async onCurrentScreenRequest(data: EventModels.CurrentScreenRequestEventModel) {
        const response: ScreenCaptureResponse = await this.screenShotCaptureService.processCurrentScreenRequest(data);

        LSAClient.getInstance().classroomEventRequestResponse.postCurrentScreen({
            width: response.width === undefined ? 0 : response.width,
            height: response.height === undefined ? 0 : response.height,
            imgData: response.imageBase64
        });
    }

    public onHeartbeatReceived(data: EventModels.HeartbeatEventModel) {
        //throw new Error('Method not implemented.');
    }

    public onChatReceived(data: EventModels.ChatReceivedEventModel) {
        this.logger.logMessage('ClassroomEventHandler onChatReceived!');
        this.chatMessage({
            data: {
                message: data.message,
                timestamp: data.sendTime,
                from: data.from
            }
        });
    }

    public onDoNotDisturbReceived(dnd: boolean) {
        this.setState({
            doNotDisturb: dnd
        });
    }

    public onClearRaiseHand() {
        this.setState({
            handRaised: false
        });
    }

    public onCloseTabsRequest() {
        //throw new Error('Method not implemented.');
    }

    public onOrgVerification(isOrgVerified: boolean) {
        this.classStatusEventSubscribers.forEach((sub) => {
            sub.onOrgVerification(isOrgVerified);
        });
    }

    public onCloseApp(closeAppInfo: EventModels.CloseAppEventModel): any {
        //throw new Error('Method not implemented.');
    }
}