//
//  Command.swift
//  AddaIOS
//
//  Created by Alif on 9/11/18.
//  Copyright © 2018 Alif. All rights reserved.
//

import Foundation

public protocol CommandDelegate: class {
    func receive(strData:String)
    func getSendData() -> String
}

public class BaseCommand: CommandDelegate {
    var time: TimeInterval
    var transaction: String
    weak var delegate: RTCVideoServer!
    var handleID: Int64
    var preData: Codable?

    public init(delegate: RTCVideoServer, handleID: Int64, data: Codable? = nil) {
        self.transaction = UUID.init().uuidString
        self.delegate = delegate
        self.handleID = handleID
        self.preData = data
        self.time = Date().timeIntervalSince1970
    }

    final public func getSendData() -> String {
        var sendData = ""
        do {
            let jsonData = try JSONSerialization.data(withJSONObject: getDataObject() as Any, options: .prettyPrinted)
            sendData = String(data: jsonData, encoding: String.Encoding.utf8)!

        } catch let error {
            print("error converting to json: \(error)")
        }
        return sendData
    }

    func getDataObject() -> [String: Any]? { return [:] }

    public func receive(strData str: String) {}
}

class CreateCommand: BaseCommand {

    override func receive(strData: String) {

        guard let data = CreateData.decode(json: strData, using: .utf8) else {
            print("missing CreateData data 53")
            return
        }

        delegate.setSessionId( data.data.id)
        delegate.sendCommand(command: AttachCommand(delegate: delegate, handleID: 0))

    }

    override func getDataObject() -> [String : Any] {
        return ["janus": "create", "transaction": transaction] as [String : Any]
    }
}

class AttachCommand: BaseCommand {
    override func receive(strData: String) {

        guard let data = AttachData.decode(json: strData, using: .utf8) else {
            print("missing AttachData data 71")
            return
        }

        handleID = data.data.id

        if delegate.type == .listParticipants {
            delegate.sendCommand(command: ListparticipantsCommand(delegate: delegate, handleID: handleID))
        } else {
            if preData == nil {
                delegate.sendCommand(command: JoinForPublisherCommand(delegate: delegate, handleID: handleID))
            } else {
                delegate.sendCommand(command: JoinForSubscriberCommand(delegate: delegate, handleID: handleID, data: preData))
            }
        }

    }

    override func getDataObject() -> [String : Any] {
        return [
            "janus":       "attach",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "plugin":      "janus.plugin.videoroom",
            "opaque_id":   "videoroomtest-"
        ] as [String : Any]
    }
}

class JoinForPublisherCommand: BaseCommand {

    override func receive(strData: String) {

        if strData.contains("event") {

            guard let data = JoinData.decode(json: strData, using: .utf8) else {
                print("missing JoinData data 106")
                return
            }

            let id = String(data.plugindata.data.id ?? 0)

            delegate.myJanusId = id
            delegate.janusIdToHandle[delegate.myJanusId] = handleID

            if delegate.initPublish {
                delegate.client?.startConnection(id, localStream: true)
                delegate.client?.makeOffer(id)
            }

            delegate.privateID = data.plugindata.data.privateId!
            var index = 0
            for publisher in data.plugindata.data.publishers {

                if index == delegate.maxViewer {
                    return
                }

                delegate.infoFromJanusId[publisher.id] = publisher
                delegate.sendCommand(command: AttachCommand(delegate: delegate, handleID: handleID, data:AttachId(id: publisher.id)))
                index += 1
            }
        }
    }

    override func getDataObject() -> [String : Any] {

        let body = [
            "display": delegate.display,
            "ptype":   "publisher",
            "request": "join",
            "room":    delegate.roomID
        ] as [String: Any]

        return [
            "janus": "message",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "body":        body
        ] as [String : Any]
    }
}

class JoinForSubscriberCommand: BaseCommand {
    override func receive(strData: String) {
        if strData.contains("event") {

            guard let data = JoinOfferData.decode(json: strData, using: .utf8) else {
                print("missing JoinOfferData data 158")
                return
            }
            let id = String(data.plugindata.data.id)

            delegate.client?.startConnection(id, localStream: false)
            delegate.client?.createAnswerForOfferReceived(id, withRemoteSDP: data.jsep.sdp)
        }
    }

    override func getDataObject() -> [String: Any]? {

        guard let pData: AttachId = preData as? AttachId else {
            print("missing AttachId")
            return nil
        }

        delegate.janusIdToHandle[String(pData.id)] = handleID

        let body = [
            "display":    "subscriber",
            "feed":       pData.id,
            "private_id": delegate.privateID,
            "ptype":      "subscriber",
            "request":    "join",
            "room":       delegate.roomID
        ] as [String: Any]

        return [
            "janus":       "message",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "body":        body
        ] as [String : Any]
    }
}

class NewJoinActiveCommand:BaseCommand {

    override func receive(strData: String) {
        if strData.contains("event") {

            guard let data = JoinData.decode(json: strData, using: .utf8) else {
                print("missing JoinData data 202")
                return
            }

            let id = data.plugindata.data.publishers[0].id
            delegate.infoFromJanusId[id] = data.plugindata.data.publishers[0]
            delegate.sendCommand(command: AttachCommand(
                                                delegate: delegate,
                                                handleID: 0,
                                                data: AttachId(id: id)))
        }
    }

}

class ReceiveUnpublishCommand:BaseCommand {

    override func receive(strData: String) {
        if strData.contains("event") {

            guard let data = UnpublishData.decode(json: strData, using: .utf8) else {
                print("missing UnpublishData data 223")
                return
            }
            delegate.disconnectMeetingById(id: String(data.plugindata.data.unpublished))
        }
    }

}

public class UnpublishCommand: BaseCommand {

    override public func receive(strData: String) {
        if strData.contains("event"), let janusId = delegate.getJanusIdFromHandId(id: handleID) {
            delegate.disconnectMeetingById(id: janusId )
        }
    }

    override func getDataObject() -> [String : Any] {
        return [
            "janus": "     message",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "body":       ["request": "unpublish"]
        ] as [String : Any]
    }
}

//---------------------------------------------------------

class ListparticipantsCommand: BaseCommand {

    override func receive(strData: String) {

        guard let data = JoinParticipantsData.decode(json: strData, using: .utf8) else {
            print("missing JoinParticipantsData data 258")
            return
        }
        delegate.sendCommand(command: JoinParticipantCommand(delegate: delegate, handleID: handleID, data:data))

    }

    override func getDataObject() -> [String : Any] {
        return [
            "janus":       "message",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "body": ["request": "listparticipants", "room": delegate.roomID] as [String: Any]
        ] as [String : Any]
    }
}

class JoinParticipantCommand: BaseCommand {

    override func receive(strData: String) {

        if strData.contains("event") {

            guard let data = JoinOfferData.decode(json: strData, using: .utf8) else {
                print("missing JoinOfferData data 283")
                return
            }

            let id = String(data.plugindata.data.id)
            var iceServers = [RTCIceServer]()
            // iceServers.append(RTCIceServer(urlStrings: iceServerdata.urls, username: iceServerdata.username, credential: iceServerdata.credential))
            iceServers.append(RTCIceServer(urlStrings:["stun:stun.l.google.com:19302"] ))
            delegate.client?.setIceServer(id, iceServers: iceServers)
            delegate.client?.startConnection(id, localStream: false)
            delegate.client?.createAnswerForOfferReceived(String(data.plugindata.data.id), withRemoteSDP: data.jsep.sdp)
        }
    }

    override func getDataObject() -> [String : Any]? {

        guard var pData: JoinParticipantsData = preData as? JoinParticipantsData else {
            print("missing JoinParticipantsData 300")
            return nil
        }

        let viewID = pData.plugindata.data.participants[0].id

        delegate.janusIdToHandle[String(viewID)] = handleID

        let body = [
            "feed":       viewID,
            "private_id": 0,
            "ptype":      "subscriber",
            "request":    "join",
            "room":       delegate.roomID
        ] as [String: Any]

        return [
            "janus":       "message",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "body":        body
        ] as [String : Any]
    }
}

import WebRTC

class SendOfferCommand: BaseCommand {

    override func receive(strData: String) {

        if strData.contains("event") {

            guard let data = OfferReturnData.decode(json: strData, using: .utf8) else {
                print("missing OfferReturnData data 335")
                return
            }

            if let id = delegate.getJanusIdFromHandId(id: data.sender) {
                delegate.client?.handleAnswerReceived(id, withRemoteSDP: data.jsep.sdp)
            }
        }

    }

    override func getDataObject() -> [String : Any]? {

        guard let pData: JsepData = preData as? JsepData else {
            print("missin JsepData line 349")
            return nil
        }

        let body = [
            "request": "configure",
            "audio":   true,
            "video":   true
        ] as [String: Any]

        let jsep = ["type": pData.type, "sdp": pData.sdp] as [String: Any]

        return [
            "janus":       "message",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "body":        body,
            "jsep":        jsep
        ] as [String : Any]
    }
}

class SendAnswerCommand: BaseCommand {

    override func getDataObject() -> [String : Any]? {
        guard let pData: JsepData = preData as? JsepData else {
            print("missin JsepData line 349")
            return nil
        }

        let body = [ "request": "start", "room": delegate.roomID ] as [String : Any]
        let jsep  = ["type": "answer", "sdp": pData.sdp] as [String : Any]

        return [
            "janus":       "message",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "body": body,
            "jsep": jsep
        ] as [String : Any]
    }
}

class SendCandidateCommand: BaseCommand {

    override func getDataObject() -> [String : Any]? {

        guard let pData: CandidateData = preData as? CandidateData else {
            print("missin CandidateData line 399")
            return nil
        }

        let candidate = [
            "candidate":     pData.candidate,
            "sdpMLineIndex": pData.lineIndex,
            "sdpMid":        pData.sdpMid
        ] as [String : Any]

        return [
            "janus":       "trickle",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "candidate":   candidate
        ] as [String : Any]
    }
}

class SendCandidateEndCommand: BaseCommand {

    override func getDataObject() -> [String : Any] {
        return [
            "janus":       "trickle",
            "transaction": transaction,
            "session_id":  delegate.sessionID,
            "handle_id":   handleID,
            "candidate": ["completed":true]
        ] as [String : Any]
    }
}

class KeepAliveCommand: BaseCommand {

    override func getDataObject() -> [String : Any] {
        return [
            "janus":       "keepalive",
            "transaction": transaction,
            "session_id":  delegate.sessionID
        ] as [String : Any]
    }
}