import { IWorker } from "../interface/IWorker";
import { EWorkerType } from "../enum/EWorkerType";
import { EWorkerStatus } from "../enum/EWorkerStatus";
import { Context } from "../../context/Context";
import { InitActionManager } from "../../manager/InitManager";
import { IAction } from "../../action/interface/IAction";
import { EActionType } from "../../action/enum/EActionType";
import { WSTransport } from "../../transport/WSTransport";
import { EActionStatus } from "../../action/enum/EActionStatus";
import { RegionChangeActionManager } from "../../manager/RegionChangeManager";
import { ActiveProxyActionManager } from "../../manager/ActiveProxyManager";
import { DisconnectManager } from "../../manager/DisconnectManager";
import { ToggleVoiceManager } from "../../manager/ToggleVoiceManager";
import { ChangeDeviceManager } from "../../manager/ChangeDeviceManager";
import { SubscribeManager } from "../../manager/SubscribeManager";
import { UnsubscribeManager } from "../../manager/UnsubscribeManager";
import { ShareCameraManager } from "../../manager/ShareCameraManager";
import { ShareScreenManager } from "../../manager/ShareScreenManager";
import { ChangeRoleManager } from "../../manager/ChangeRoleManager";
import { ChangeModuleConfigManager } from "../../manager/ChangeModuleConfigManager";
import { ToggleVoiceActionParams } from "../../action/type/ToggleVoiceActionParams";
import { ShareCameraActionParams } from "../../action/type/ShareCameraActionParams";
import { ShareScreenActionParams } from "../../action/type/ShareScreenActionParams";
import { RegionChangeActionParams } from "../../action/type/RegionChangeActionParams";

export class BaseWorker implements IWorker {

    public actions!: Array<IAction>;
    public time: number = 100;
    public type!: EWorkerType;
    public status!: EWorkerStatus;
    public datetime!: number;
    public context!: Context;
    public maxIntents = 5;
    public working: boolean = false;
    public deleteActionCallback!: Function;
    public reintentActionCallback!: Function;
    public tranport!: WSTransport;

    public isWorking(): boolean {
        return this.working;
    }

    public getContext(): Context {
        return this.context;
    }
    public setContext(value: Context) {
        this.context = value;
    }

    public getActions(): Array<IAction> {
        return this.actions;
    }
    public setActions(value: Array<IAction>) {
        this.actions = value;
    }

    public getDeleteActionCallback(): Function {
        return this.deleteActionCallback;
    }

    public setDeleteActionCallback(value: Function) {
        this.deleteActionCallback = value;
    }

    public getReintentActionCallback(): Function {
        return this.reintentActionCallback;
    }

    public setReintentActionCallback(value: Function) {
        this.reintentActionCallback = value;
    }

    public getTranport(): WSTransport {
        return this.tranport;
    }
    public setTranport(value: WSTransport) {
        this.tranport = value;
    }

    public async performeAction(action: IAction): Promise<EActionStatus> {
        return new Promise<EActionStatus>(async (resolve) => {

            let manager;
            let statusAction = action.status;

            switch (action.type) {
                case EActionType.INIT_AGORA:
                    manager = new InitActionManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.REGION_CHANGE:
                    manager = new RegionChangeActionManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.ACTIVE_PROXY:
                    manager = new ActiveProxyActionManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.DISCONNECT:
                    manager = new DisconnectManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.TOGGLE_VOICE:
                    manager = new ToggleVoiceManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.CHANGE_DEVICE:
                    manager = new ChangeDeviceManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.SUBSCRIBE:
                    manager = new SubscribeManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.UNSUBSCRIBE:
                    manager = new UnsubscribeManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.SHARE_CAMERA:
                    manager = new ShareCameraManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.SHARE_SCREEN:
                    manager = new ShareScreenManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.CHANGE_ROLE:
                    manager = new ChangeRoleManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                case EActionType.CHANGE_MODULE_CONFIG:
                    manager = new ChangeModuleConfigManager(action, this.context);
                    statusAction = await manager.performAction();
                    break;

                default:
                    break;
            }

            resolve(statusAction);

        });
    }

    public doConfirmToTransport(action: IAction, status: EActionStatus) {
        try {
            if (this.context.getDeterminants() && this.context.getDeterminants().getTranport() && action.requiredConfirm) {
                let  messages= this.inflateMessageConfirm(action, status);
                messages.forEach((message)=>{
                    this.context.getDeterminants().getTranport().getInstanceEmiterCallback().send(JSON.stringify(message));
                });
            }
        } catch (error) { }
    }

    public inflateMessageConfirm(action: IAction, status: EActionStatus) {

        let message = [];
        let channel! : string;

        try {
            switch (action.type) {

                case EActionType.TOGGLE_VOICE:

                    let toggleVoiceActionParams: ToggleVoiceActionParams = Object.assign(action.params);

                    switch (status) {

                        case EActionStatus.PERFORMED:
                            message.push({
                                "payloadType": "muteAck",
                                "payload": {
                                    "IsMuted": (toggleVoiceActionParams.action) + "",
                                    "userId": this.context.getDeterminants().getUserInformation().userId + ""
                                }
                            });
                        break;

                        case EActionStatus.FAILED:
                            message.push({ 
                                "payloadType": "muteAck", 
                                "payload": { 
                                    "IsMuted": (!toggleVoiceActionParams.action) + "", 
                                    "userId": this.context.getDeterminants().getUserInformation().userId + "" 
                                } 
                            });
                        break;


                        default:
                            break;
                    }
                    break;

                case EActionType.SHARE_CAMERA:

                    let shareCameraActionParams: ShareCameraActionParams = Object.assign(action.params);

                    switch (status) {

                        case EActionStatus.PERFORMED:

                        channel = this.context.getDeterminants().getChannel() != undefined ? this.context.getDeterminants().getChannel()+"" : "";

                        if( channel.indexOf("private-user-"+this.context.getDeterminants().getUserInformation().userId) < 0){
                            
                            message.push({ 
                                    "payloadType": "frameUIAck", 
                                    "payload": {
                                        "userId": this.context.getDeterminants().getUserInformation().userId+"", 
                                        "action": shareCameraActionParams.active ? "openWebcam" : "closeWebcam" 
                                    } 
                            });
                            
                            message.push({
                                "payloadType":"frameCameraChange",
                                "payload":{"presenting": shareCameraActionParams.active + "" }
                            });

                        }

                        break;

                        case EActionStatus.FAILED:

                            channel = this.context.getDeterminants().getChannel() != undefined ? this.context.getDeterminants().getChannel()+"" : "";

                            if( channel.indexOf("private-user-"+this.context.getDeterminants().getUserInformation().userId) < 0){

                                message.push({ 
                                    "payloadType": "frameUIAck", 
                                    "payload": {
                                        "userId": this.context.getDeterminants().getUserInformation().userId+"", 
                                        "action": shareCameraActionParams.active ? "closeWebcam" : "openWebcam"  
                                    } 
                                });

                                message.push({
                                    "payloadType":"frameCameraChange",
                                    "payload":{"presenting": (!shareCameraActionParams.active)+""}
                                });	

                            }

                        break;


                        default:
                            break;
                    }
                    break;

                case EActionType.SHARE_SCREEN:

                    let shareScreenActionParams: ShareScreenActionParams = Object.assign(action.params);

                    switch (status) {

                        case EActionStatus.PERFORMED:
                            message.push({ 
                                    "payloadType": "frameUIAck", 
                                    "payload": {
                                        "userId": this.context.getDeterminants().getUserInformation().userId+"", 
                                        "action": shareScreenActionParams.active ? "openShareScreen" : "closeShareScreen"
                                    } 
                            });
                            message.push({
                                "payloadType":"screenIndicator", 
                                "payload":{
                                    "screen_uid":this.context.getDeterminants().getUid(),
                                    "sharing":shareScreenActionParams.active+""
                                }
                            });
                        break;

                        case EActionStatus.FAILED:
                            message.push({ 
                                "payloadType": "frameUIAck", 
                                "payload": {
                                    "userId": this.context.getDeterminants().getUserInformation().userId+"", 
                                    "action": shareScreenActionParams.active ? "closeShareScreen" : "openShareScreen"
                                } 
                            });
                            message.push({
                                "payloadType":"screenIndicator", 
                                "payload":{
                                    "screen_uid":this.context.getDeterminants().getUid(),
                                    "sharing":(!shareScreenActionParams.active)+""
                                }
                            });
                        break;


                        default:
                            break;
                    }
                    break;

                case EActionType.REGION_CHANGE:

                    let regionChangeActionParams: RegionChangeActionParams = Object.assign(action.params);

                    switch (status) {

                        case EActionStatus.PERFORMED:

                            let client : any = this.context.getResources() && this.context.getResources().getClient() ? this.context.getResources().getClient() : null;

                            message.push({
                                "payloadType":"regionConfirm",
                                "payload":{
                                    "UserId":this.context.getDeterminants().getUserInformation().userId+"", 
                                    "EventId":this.context.getDeterminants().getUserInformation().currentEventId+"", 
                                    "Region":" ",
                                    "RegionId":""+regionChangeActionParams.channel,
                                    "AgoraRole":""+regionChangeActionParams.role,
                                    "EnteredRegion":"true",
                                    "AgoraAccount": client ? client._joinInfo.uid : '',
                                    "Session":" ",
                                }}		
                            );

                            if(regionChangeActionParams.channel.indexOf("private-user-"+this.context.getDeterminants().getUserInformation().userId) < 0 
                                && regionChangeActionParams.keepTracks!=false){

                                if(this.context.getDeterminants().getHasCamera()){
                                    message.push({ 
                                        "payloadType": "frameUIAck", 
                                        "payload": {
                                            "userId": this.context.getDeterminants().getUserInformation().userId+"", 
                                            "action": this.context.getDeterminants().getHasCamera() ? "openWebcam" : "closeWebcam" 
                                        } 
                                    });
                                    
                                    message.push({
                                        "payloadType":"frameCameraChange",
                                        "payload":{"presenting": this.context.getDeterminants().getHasCamera() + "" }
                                    });
                                }
    
                                if(this.context.getDeterminants().getHasScreen()){
                                    message.push({ 
                                        "payloadType": "frameUIAck", 
                                        "payload": {
                                            "userId": this.context.getDeterminants().getUserInformation().userId+"", 
                                            "action": this.context.getDeterminants().getHasScreen() ? "openShareScreen" : "closeShareScreen"
                                        } 
                                    });
                                    message.push({
                                        "payloadType":"screenIndicator", 
                                        "payload":{
                                            "screen_uid": this.context.getDeterminants().getUid(),
                                            "sharing": this.context.getDeterminants().getHasScreen()+""
                                        }
                                    });
                                }
                            }


                        break;

                        default:
                            break;
                    }
                break;

                default:
                break;
            }
        } catch (error) { }


        return message;
    }

    public run(): void { }

    public async handlerAction(action: IAction) {

        if (action) {

            
            let statusAction = await this.performeAction(action);
            
            if(action.status == EActionStatus.KEEPOUT){
                this.getDeleteActionCallback()(action.id + ":" + Date.now());
            }else if (statusAction == EActionStatus.PERFORMED) {

                //EMIT SUCCESS CONFIRM

                this.doConfirmToTransport(action, EActionStatus.PERFORMED);

                this.getDeleteActionCallback()(action.id + ":" + Date.now());

            } else if (statusAction == EActionStatus.FAILED) {

                if (action.requiredReintent == true && action.intent < this.maxIntents) {

                    this.getReintentActionCallback()(action.id + ":" + Date.now());

                } else {

                    //EMIT ERROR CONFIRM

                    this.doConfirmToTransport(action, EActionStatus.FAILED);

                    this.getDeleteActionCallback()(action.id + ":" + Date.now());

                }

            } else {

                //EMIT ERROR CONFIRM

                this.doConfirmToTransport(action, EActionStatus.FAILED);

                this.getDeleteActionCallback()(action.id + ":" + Date.now());

            }

        }

        this.working = false;
    }

}