/**
 *  Copyright (C) Sebastian YEPES
 *  Original Authors: Sam Lalor, Andrew Stanley-Jones
 *
 *  Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 *  in compliance with the License. You may obtain a copy of the License at:
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
 *  on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
 *  for the specific language governing permissions and limitations under the License.
 *
 */

import groovy.json.JsonSlurper
import groovy.json.JsonOutput
import groovy.transform.Field

@Field String VERSION = "1.0.0"

@Field List<String> LOG_LEVELS = ["error", "warn", "info", "debug", "trace"]
@Field String DEFAULT_LOG_LEVEL = LOG_LEVELS[2]
@Field static Map callbacks = [:]

metadata {
  definition (name: "LG WebOS TV", namespace: "syepes", author: "Sebastian YEPES", importUrl: "https://raw.githubusercontent.com/syepes/Hubitat/master/Drivers/LG/LG%20WebOS%20TV.groovy") {
    capability "Initialize"
    capability "TV"
    capability "AudioVolume"
    capability "Refresh"
    capability "Switch"
    capability "Notification"

    command "off"
    command "refresh"
    command "refreshInputList"
    command "getMouseURI"
    command "externalInput", ["string"]
    command "sendJson", ["string"]
    command "myApps"
    command "ok"
    command "home"
    command "left"
    command "right"
    command "up"
    command "down"
    command "back"
    command "enter"
    command "notificationIcon", ["string", "string"]
    command "setIcon", ["string", "string"]
    command "clearIcons"
    command "testWebSocketReply", ["string"]

    attribute "availableInputs", "list"

    attribute "channelDesc", "string"
    attribute "channelName", "string"
    attribute "channelFullNumber", "string"
  }

  preferences {
    section { // General
      input name: "logLevel", title: "Log Level", type: "enum", options: LOG_LEVELS, defaultValue: DEFAULT_LOG_LEVEL, required: false
      input name: "logDescText", title: "Log Description Text", type: "bool", defaultValue: false, required: false
    }
    section { // Configuration
      input name: "televisionIp", type: "text", title: "Television IP Address",  defaultValue: "",  required: true
      input name: "televisionMac", type: "text", title: "Television MAC Address", defaultValue: "",  required: true
      input name: "pairingKey", type: "text", title: "Pairing Key", required: true, defaultValue: ""
      input name: "retryDelay", title: "Device Reconnect delay", type: "enum", options: [["5":"Retry every 5 seconds"], ["10":"Retry every 10 seconds"], ["15":"Retry every 15 seconds"], ["30":"Retry every 30 seconds"], ["45":"Retry every 45 seconds"], ["60":"Retry every minute"], ["120":"Retry 2 minute"], ["300":"Retry every 5 minutes"], ["600":"Retry every 10 minutes"]], defaultValue: 60
    }
  }
}


def installed() {
  logger("debug", "installed() - settings: ${settings?.inspect()}")
//    initialize()
}

def refresh() {
  logger("debug", "refresh()")
  state.deviceInfo = null
  state.televisionModel = null
  state.nameToInputId = null

  webosRegister()
}

def webosRegister() {
  logger("debug", "webosRegister() - pairing key: ${state.pairingKey}")
  state.pairFailCount = 0

  def payload = [
    pairingType: "PROMPT",
    forcePairing: false,
    'client-key': state?.pairingKey,
    manifest: [
      appVersion: "1.1",
      signed: [
        localizedVendorNames: [ "": "LG Electronics" ],
        appId: "com.lge.test",
        created: "20140509",
        permissions: [
          "TEST_SECURE",
          "CONTROL_INPUT_TEXT",
          "CONTROL_MOUSE_AND_KEYBOARD",
          "READ_INSTALLED_APPS",
          "READ_LGE_SDX",
          "READ_NOTIFICATIONS",
          "SEARCH",
          "WRITE_SETTINGS",
          "WRITE_NOTIFICATION_ALERT",
          "CONTROL_POWER",
          "READ_CURRENT_CHANNEL",
          "READ_RUNNING_APPS",
          "READ_UPDATE_INFO",
          "UPDATE_FROM_REMOTE_APP",
          "READ_LGE_TV_INPUT_EVENTS",
          "READ_TV_CURRENT_TIME",
        ],
        localizedAppNames: [
          "": "LG Remote App",
          "ko-KR": "리모컨 앱",
          "zxx-XX": "ЛГ Rэмotэ AПП",
        ],
        vendorId: "com.lge",
        serial: "2f930e2d2cfe083771f68e4fe7bb07",
      ],
      permissions: [
        "LAUNCH",
        "LAUNCH_WEBAPP",
        "APP_TO_APP",
        "CLOSE",
        "TEST_OPEN",
        "TEST_PROTECTED",
        "CONTROL_AUDIO",
        "CONTROL_DISPLAY",
        "CONTROL_INPUT_JOYSTICK",
        "CONTROL_INPUT_MEDIA_RECORDING",
        "CONTROL_INPUT_MEDIA_PLAYBACK",
        "CONTROL_INPUT_TV",
        "CONTROL_POWER",
        "READ_APP_STATUS",
        "READ_CURRENT_CHANNEL",
        "READ_INPUT_DEVICE_LIST",
        "READ_NETWORK_STATE",
        "READ_RUNNING_APPS",
        "READ_TV_CHANNEL_LIST",
        "WRITE_NOTIFICATION_TOAST",
        "READ_POWER_STATE",
        "READ_COUNTRY_INFO",
      ],
      manifestVersion: 1,
      signatures: [
        [
          signatureVersion: 1,
          signature: "eyJhbGdvcml0aG0iOiJSU0EtU0hBMjU2Iiwia2V5SWQiOiJ0ZXN0LXNpZ25pbmctY2VydCIsInNpZ25hdHVyZVZlcnNpb24iOjF9.hrVRgjCwXVvE2OOSpDZ58hR+59aFNwYDyjQgKk3auukd7pcegmE2CzPCa0bJ0ZsRAcKkCTJrWo5iDzNhMBWRyaMOv5zWSrthlf7G128qvIlpMT0YNY+n/FaOHE73uLrS/g7swl3/qH/BGFG2Hu4RlL48eb3lLKqTt2xKHdCs6Cd4RMfJPYnzgvI4BNrFUKsjkcu+WD4OO2A27Pq1n50cMchmcaXadJhGrOqH5YmHdOCj5NSHzJYrsW0HPlpuAx/ECMeIZYDh6RMqaFM2DXzdKX9NmmyqzJ3o/0lkk/N97gfVRLW5hA29yeAwaCViZNCP8iC9aO0q9fQojoa7NQnAtw==",
        ],
      ]
    ]
  ]

  sendWebosCommand(type: "register", payload: payload, callback: { json ->
    logger("trace", "webosRegister() - json: ${json?.inspect()}")

    if (json?.type == "registered") {
      pKey = json.payload["client-key"]
      if (pKey != null) {
        logger("debug", "webosRegister() - received registered client-key: ${pKey}")

        state.pairingKey = pKey
        device.updateSetting("pairingKey",[type:"text", value:"${pKey}"])
        runInMillis(10, webosSubscribeToStatus)
        runInMillis(25, getMouseURI)
        // Hello doesn't seem to do anything?
        if (!state.deviceInfo) runInMillis(50, sendHello)
        if (!state.televisionModel) runInMillis(75, sendRequestInfo)
        if (!state.nameToInputId) runInMillis(100, refreshInputList)
        if (!state.serviceList) runInMillis(125, getServiceList)
      }
      return true
    } else if (json?.type == "response") {
        return false
    }
  })
}

def sendHello() {
  logger("debug", "sendHello()")
  sendWebosCommand(type: "hello", id: "hello")
}

def handler_hello(data) {
  logger("debug", "handler_hello() - data: ${data?.inspect()}")
  state.deviceInfo = data
}

def sendRequestInfo() {
  logger("debug", "sendRequestInfo()")

  sendWebosCommand(uri: "system/getSystemInfo", callback: { json ->
    logger("trace", "sendRequestInfo() - json: ${json?.inspect()}")
    state.televisionModel = json.payload?.modelName
    state.televisionReceiver = json.payload?.receiverType
  })
}

def refreshInputList() {
  logger("debug", "refreshInputList() - current list size: ${state.nameToInputId?.size()}")

  sendWebosCommand(uri: "com.webos.applicationManager/listLaunchPoints", payload: [], callback: { json ->
    logger("trace", "refreshInputList() - json: ${json?.inspect()}")
    def inputList = []
    def nameToInputId = [:]
    json?.payload?.launchPoints.each { app ->
      logger("debug", "refreshInputList() - App Name: ${app.title}, App: ${app}")
      inputList += app.title
      nameToInputId[app.title] = app.id
    }

    state.nameToInputId = nameToInputId
    state.inputList = inputList

    sendWebosCommand(uri: 'tv/getExternalInputList', callback: { jsonExt ->
      logger("trace", "refreshInputList() - jsonExt: ${jsonExt?.inspect()}")

      jsonExt?.payload?.devices?.each { device ->
        logger("debug", "refreshInputList() - Device: ${device?.label}")
        inputList += device.label
        nameToInputId[device.label] = device.appId
      }
      state.nameToInputId = nameToInputId
      state.inputList = inputList
      logger("debug", "refreshInputList() - Inputs: ${state.inputList}")

      sendEvent(name: "availableInputs", value: inputList);
    })

  })
}

def getMouseChild() {
  logger("debug", "getMouseChild() - televisionIp: ${televisionIp}")

  try {
    def mouseDev = getChildDevice("LG_TV_Mouse_${televisionIp}")
    if(!mouseDev) mouseDev = addChildDevice("syepes", "LG WebOS Mouse", "LG_TV_Mouse_${televisionIp}")
    return mouseDev
  } catch(e) {
    logger("error", "getMouseChild() - Failed to get mouse dev: ${e}")
  }
  return null
}

def getMouseURI() {
  logger("debug", "getMouseURI()")

  def mouseDev = getMouseChild()

  sendWebosCommand(uri: "com.webos.service.networkinput/getPointerInputSocket", payload: [], callback: { json ->
    logger("trace", "getMouseURI() - json: ${json?.inspect()}")

    if (json?.payload?.socketPath) {
      logger("debug", "getMouseURI() - Send Mouse driver URI: ${json.payload.socketPath}")
      mouseDev?.setMouseURI(json.payload.socketPath)
    }
  })
}

def sendJson(String json) {
  sendCommand(json);
}

def powerEvent(String onOrOff, String type = "digital") {
  logger("debug", "powerEvent() - onOrOff: ${onOrOff}, type: ${type}")

  def descriptionText = "is ${onOrOff}"
  if (state.power != onOrOff){
    logger("info", "powerEvent() - ${descriptionText} [$type]")
  }

  state.power = onOrOff
  sendEvent(name: "switch", value: onOrOff, descriptionText: descriptionText, type: type)
  if (type == "physical") {
    sendEvent(name: "power", value: onOrOff, descriptionText: descriptionText, type: type)
  }

  if ((onOrOff == "off") && (type == "physical")) {
    sendEvent(name: "channelDesc", value: "[off]", descriptionText: descriptionText)
    sendEvent(name: "channelName", value: "[off]", descriptionText: descriptionText)
    sendEvent(name: "input", value: "[off]", descriptionText: descriptionText)
    // Socket status should follow the system reported status
    interfaces.webSocket.close()
  }
}

def initialize() {
  logger("debug", "initialize() - ip: ${televisionIp}, mac: ${televisionMac}, key: ${pairingKey}, debug: ${debug}, logText: ${descriptionText}")
  logger("debug", "initialize() - settings: ${settings.inspect()}")

  // Websocket has closed/errored, erase all callbacks
  callbacks = [:]

  // Set some basic state, clear channel info
  state.sequenceNumber = 1
  state.lastChannel = [:]
  state.pairFailCount = 0

  // When reconnectPending is true it stops reconnectWebsocket
  // from rescheudling initialize()
  state.reconnectPending = false
  state.webSocket = "initialize"

  unschedule()

  def mouseDev = getMouseChild()

  interfaces.webSocket.close()

  if(!televisionMac) {
    def mac = getMACFromIP(televisionIp)
    if (mac){
      device.updateSetting("televisionMac",[value:mac,type:"string"])
    }
  }

  try {
    logger("info", "initialize() - Connecting websocket to: ws://${televisionIp}:3000/")
    interfaces.webSocket.connect("ws://${televisionIp}:3000/")
  } catch(e) {
    logger("error", "initialize() - WebSocket connect ${e?.inspect()}")
  }
}

def webSocketStatus(String status){
  logger("debug", "webSocketStatus() - status: [${status}], State: [${state.webSocket}]")

  if(status.startsWith('failure: ')) {
    //logger("error", "webSocketStatus() - ${status}")

    if ((status == "failure: No route to host (Host unreachable)") || (status == "failure: connect timed out") || status.startsWith("failure: Failed to connect") || status.startsWith("failure: sent ping but didn't receive pong")) {
      logger("info", "webSocketStatus() - WebSocket is closed")
      powerEvent("off", "physical")
    }
    state.webSocket = "closed"
    reconnectWebSocket()
  } else if(status == 'status: open') {
    logger("info", "webSocketStatus() - WebSocket is open")

    // success! reset reconnect delay
    powerEvent("on", "physical")
    state.webSocket = "open"
    webosRegister()
    state.reconnectDelay = 2
  } else if (status == "status: closing"){
    logger("info", "webSocketStatus() - WebSocket connection closing")
    unschedule()

    if (state.webSocket == 'initialize') {
      logger("info", "webSocketStatus() - Ignoring WebSocket close due to initialization")
    } else {
      if (state.power == "on") {
        // TV should be on and reachable - try to reconnect
        reconnectWebSocket(1)
      } else {
        reconnectWebSocket()
      }
    }
    state.webSocket = "closed"
  } else {
    logger("error", "webSocketStatus() - WebSocket error, reconnecting")
    powerEvent("off", "physical")
    state.webSocket = "closed"
    reconnectWebSocket()
  }
}

def reconnectWebSocket(delay = null) {
  logger("debug", "reconnectWebSocket() - delay: ${delay}")

  // first delay is 2 seconds, doubles every time
  if (state.reconnectPending == true) {
    logger("warn", "reconnectWebSocket() - Rejecting additional reconnect request")
    return
  }
  delay = delay ?: state.reconnectDelay
  state.reconnectDelay = delay * 2
  settings_retryDelay = settings.retryDelay.toInteger()
  // don't let delay get too crazy, max it out at user setting
  if (state.reconnectDelay > settings_retryDelay) {
    state.reconnectDelay = settings_retryDelay
  }

  //If the TV is offline, give it some time before trying to reconnect
  state.reconnectPending = true
  runIn(delay, initialize)
}

def updated() {
  logger("debug", "updated() - ip: ${settings.televisionIp}, mac: ${settings.televisionMac}, key: ${settings.pairingKey}")
  initialize()
}

def logsStop() {
  logger("debug", "logsStop()")
}

def setParameters(String IP, String MAC, String TVTYPE, String KEY) {
  logger("debug", "setParameters() - ip: ${IP}, mac: ${MAC}, type: ${TVTYPE}, key: ${KEY}")

  state.televisionIp = IP
  device.updateSetting("televisionIp",[type:"text", value:IP])

  state.televisionMac = MAC
  device.updateSetting("televisionMac",[type:"text", value:MAC])
}

def testWebSocketReply(String data) {
    logger("debug", "testWebSocketReply() - data: ${data}")
    parse(data)
}

// parse events into attributes
def parse(String description) {
  logger("debug", "parse() - description: ${description}")

  // parse method is shared between HTTP and Websocket implementations
  def json = null
    try {
      json = new JsonSlurper().parseText(description)
      if(json == null){
        logger("warn", "parse() - String description not parsed")
        return
      }
    } catch(e) {
      logger("error", "parse() - Failed to parse json e = ${e}")
      return
    }

    if (this."handler_${json.id}") {
      this."handler_${json.id}"(json.payload)
    } else if (this."handler_${json.type}") {
      this."handler_${json.type}"(json.payload)
    } else if (callbacks[json.id]) {
      logger("debug", "parse() - callback for json.id: " + json.id)

      callbacks[json.id].delegate = this
      callbacks[json.id].resolveStrategy = Closure.DELEGATE_FIRST
      def done = callbacks[json.id].call(json)
      if ((done instanceof Boolean) && (done == false)) {
        logger("debug", "parse() - callback[${json.id}]: being kept, done is false")
      } else {
        callbacks[json.id] = null
      }
  } else if (json?.type == "error") {
    if (json?.id == "register_0") {
      if (json?.error.take(3) == "403") {
        // 403 error cancels the pairing process
        pairingKey = ""
        state.pairFailCount = state.pairFailCount ? state.pairFailCount + 1 : 1
        logger("debug", "parse() -  received register_0 error: ${json.error} fail count: ${state.pairFailCount}")
        if (state.pairFailCount < 6) { webosRegister() }
      }
    } else {
      if (json?.error.take(3) == "401") {
        logger("warn", "parse() - received error: ${json.error}")
        //if (state.registerPending == false) { webosRegister() }
        //webosRegister()
      }
    }
  }
}

def webosSubscribeToStatus() {
  logger("debug", "webosSubscribeToStatus()")

  sendWebosCommand(uri: 'audio/getStatus', type: 'subscribe', id: 'audio_getStatus')
  sendWebosCommand(uri: 'com.webos.applicationManager/getForegroundAppInfo', type: 'subscribe', id: 'getForegroundAppInfo')
  sendWebosCommand(uri: 'tv/getChannelProgramInfo', type: 'subscribe', id: 'getChannelProgramInfo')
  //sendCommand('{"type":"subscribe","id":"status_%d","uri":"ssap://com.webos.applicationManager/getForegroundAppInfo"}')
  sendCommand('{"type":"subscribe","id":"status_%d","uri":"ssap://com.webos.service.tv.time/getCurrentTime"}')

// schedule a poll every 10 minutes to help keep the websocket open
// runEvery10Minutes("webosSubscribeToStatus")
}

def getServiceList() {
  logger("debug", "getServiceList()")

  state.remove('serviceList')
  state.serviceList = []
  sendWebosCommand(uri: 'api/getServiceList', callback: { json ->
    logger("trace", "getServiceList() - json: ${json.serviceList}")
    json?.payload?.services.each { service ->
      state.serviceList << service?.name
    }
    logger("debug", "getServiceList() - Services: ${state.serviceList}")
  })
}

def handler_audio_getStatus(data) {
    logger("debug", "handler_audio_getStatus() - data: ${data?.inspect()}")
    def descriptionText = "volume is ${data.volume}"

    logger("info", "${descriptionText}")
    sendEvent(name: "volume", value: data.volume, descriptionText: descriptionText)
}

def handler_getForegroundAppInfo(data) {
  logger("debug", "handler_getForegroundAppInfo() - data: ${data?.inspect()}")

  // Some TVs send this message when powering off
  // data: [subscribed:true, appId:, returnValue:true, windowId:, processId:]
  // json for testing: {"type":"response","id":"getForegroundAppInfo","payload":{"subscribed":true,"appId":"","returnValue":true,"windowId":"","processId":""}}
  if (!data.appId && !data.processId) {
    powerEvent("off", "physical")
    logger("info", "handler_getForegroundAppInfo() - Received POWER DOWN notification")
    return
  }

  def appId = data.appId
  def niceName = appId
  state.nameToInputId.each { name, id ->
    if (appId == id) niceName = name
  }

  def descriptionText = "channelName is ${niceName}"
  logger("info", "${descriptionText}")

  sendEvent(name: "channelName", value: niceName, descriptionText: descriptionText)
  if (niceName != "LiveTV") sendEvent(name: "channelDesc", value: "[none]")

  state.lastApp = niceName
  if (niceName == "LiveTV") {
    runIn(3, "getChannelInfo")
  } else {
    state.lastChannel = [:]
  }
}

def getChannelInfo() {
  logger("debug", "getChannelInfo()")
  sendWebosCommand(uri: 'tv/getChannelProgramInfo', id: 'getChannelProgramInfo')
}

def handler_getChannelProgramInfo(data) {
  logger("debug", "handler_getChannelProgramInfo() - data: ${data?.inspect()}")

  if (data.errorCode) {
    def lastChannel = [:]
    lastChannel.description = "${data.errorText}"
    state.lastChannel = lastChannel
    sendEvent(name: "channelDesc", value: lastChannel.channelDesc)
    // Resubscribe, after error subscription appears to be ended
    if (device.currentChannelName == "LiveTV") {
      runIn(15, "getChannelInfo")
    }
    return
  }

  def lastChannel = [
    description: "${data.channel?.channelNumber}/${data.channel?.channelName}",
    number: data.channel?.channelNumber,
    majorNumber: data?.channel?.majorNumber ?: data.channel?.channelNumber,
    minorNumber: data?.channel?.minorNumber ?: 0,
    name: data.channel?.channelName ?: "",
  ]

  state.lastChannel = lastChannel
  sendEvent(name: "channelDesc", value: lastChannel.description)
  // This is defined as a number, not a decimal so send the major number
  def descriptionText = "full channel number is ${lastChannel?.majorNumber}-${lastChannel?.minorNumber}"
  sendEvent(name: "channel", value: lastChannel?.majorNumber)
  logger("info", "${descriptionText}")

  descriptionText = "channelName is ${lastChannel.name}"
  sendEvent(name: "channelName", value: lastChannel.name, descriptionText: descriptionText)
  logger("info", "${descriptionText}")
}

def genericHandler(json) {
  logger("debug", "genericHandler() - json: ${data?.inspect()}")
}

def deviceNotification(String notifyMessage) {
  logger("debug", "deviceNotification() - notifyMessage: ${notifyMessage?.inspect()}")

  def icon_info = notifyMessage =~ /^\[(.+?)\](.+)/
  logger("debug", "deviceNotification() - new message $notifyMessage found icon: ${icon_info != null}")

  if (!icon_info) {
    sendWebosCommand(uri: "system.notifications/createToast", payload: [message: notifyMessage])
  } else {
    logger("debug", "deviceNotification() - icon_name match ${icon_name}")
    def icon_name = icon_info[0][1]
    def msg = icon_info[0][2]
    notificationIcon(msg, icon_name)
  }
}

def setIcon(String icon_name, String data) {
  logger("debug", "setIcon() - icon_name: ${icon_name?.inspect()}, data: ${data?.inspect()}")
  state.icon_data[icon_name] = data
}

def clearIcons() {
  logger("debug", "clearIcons()")
  state.icon_data = [:]
}

def notificationIcon(String notifyMessage, String icon_name) {
  logger("debug", "notificationIcon() - notifyMessage: ${notifyMessage?.inspect()}, icon_name: ${icon_name?.inspect()}")

  def base_url = "https://raw.githubusercontent.com/pasnox/oxygen-icons-png/master/oxygen/32x32"
  def icon_extention = "png"
  def full_uri = "${base_url}/${icon_name}.png"

  if (!state.icon_data) {
    state.icon_data = [:]
  }

  if (!state.icon_data[icon_name]) {
    try {
      logger("info", "notificationIcon() - asking for ${full_uri}")

      def start_time = now()
      httpGet(full_uri, { resp ->
        handleIconResponse(resp, [
          icon_extention: icon_extention,
          icon_name: icon_name,
          notify_message: notifyMessage,
          start_time: start_time
        ])
      })

    } catch (Exception e) {
      logger("warn", "notificationIcon() - asking for ${full_uri}")
      deviceNotification("<Failed to find icon: ${e.message}>${notifyMessage}")
    }
  } else {
    String icon = state.icon_data[icon_name]
    logger("debug", "notificationIcon() - icon size: ${icon.size()} sending notifcation: ${notifyMessage} name: ${icon_name} icon: ${state.icon_data[icon_name]}")
    sendWebosCommand(uri: "system.notifications/createToast", payload: [message: notifyMessage, iconData: icon, iconExtension: icon_extention])
  }
}

def handleIconResponse(resp, data) {
  logger("debug", "handleIconResponse() - resp: ${resp?.inspect()}, data: ${data?.inspect()}")

  int n = resp.data?.available()
  logger("debug", "handleIconResponse() - resp.status: ${resp.status} took: ${now() - data.start_time}ms size: ${n}")

  byte[] bytes = new byte[n]
  resp.data.read(bytes, 0, n)
  def base64String = bytes.encodeBase64().toString()
  logger("debug", "handleIconResponse() - size of b64: ${base64String.size()}")

  state.icon_data[data.icon_name] = base64String
  notificationIcon(data.notify_message, data.icon_name)
}

def on() {
  logger("debug", "on()")

  powerEvent("on")
  def mac = settings.televisionMac ?: state.televisionMac
  if (!mac) {
    logger("error", "on() - No mac address know for TV, can't send wake on lan")
    return
  }

  logger("info", "on() - Sending Magic Packet to: ${mac}")
  def result = new hubitat.device.HubAction (
    "wake on lan ${mac}",
    hubitat.device.Protocol.LAN,
    null,[secureCode: “0000”]
  )

  logger("debug", "on() - Sending Magic Packet to: ${mac}, result: ${result}")
  return result
}

def off() {
  logger("debug", "off()")
  powerEvent("off")
  sendWebosCommand(uri: 'system/turnOff')
}

def channelUp() {
  logger("debug", "channelUp()")
  sendWebosCommand(uri: 'tv/channelUp')
}

def channelDown() {
  logger("debug", "channelDown()")
  sendWebosCommand(uri: 'tv/channelDown')
}

// handle commands
def volumeUp() {
  logger("debug", "volumeUp()")
  sendWebosCommand(uri: 'audio/volumeUp')
}

def volumeDown() {
  logger("debug", "volumeDown()")
  sendWebosCommand(uri: 'audio/volumeDown')
}

def setVolume(level) {
  logger("debug", "setVolume() - level: ${level}")
  sendWebosCommand(uri: 'audio/setVolume', payload: [volume: level])
}

def setLevel(level) {
  logger("debug", "setLevel() - level: ${level}")
  setVolume(level)
}

def sendMuteEvent(muted) {
  logger("debug", "sendMuteEvent() - muted: ${muted}")

  def descriptionText = "mute is ${muted}"
  logger("info", "${descriptionText}")
  sendEvent(name: "mute", value: muted, descriptionText: descriptionText)
}

def unmute() {
  logger("debug", "unmute()")
  sendWebosCommand(uri: 'audio/setMute', payload: [mute: false], callback: { json ->
    logger("trace", "unmute() - json: ${json}")
    if (json?.payload?.returnValue) {
      sendMuteEvent("unmuted")
    }
  })
}

def mute() {
  logger("debug", "mute()")
  sendWebosCommand(uri: 'audio/setMute', payload: [mute: true], callback: { json ->
  logger("trace", "mute() - json: ${json}")
    if (json?.payload?.returnValue) {
      sendMuteEvent("muted")
    }
  })
}

def externalInput(String input) {
  logger("debug", "externalInput() - input: ${input}")

  if (state.nameToInputId && state.nameToInputId[input]) {
    input = state.nameToInputId[input]
  }
  sendWebosCommand(uri: "system.launcher/launch", payload: [id: input], callback: { json ->
    logger("trace", "externalInput() - json: ${json}")
  })
}

def enter() {
  logger("debug", "enter()")

  def mouseDev = getMouseChild()
  mouseDev?.sendButton('ENTER')
//return sendWebosCommand(uri: "com.webos.service.ime/sendEnterKey")
}

def back() {
  logger("debug", "back()")
  def mouseDev = getMouseChild()
  mouseDev?.sendButton('BACK')
}

def up() {
  logger("debug", "up()")
  def mouseDev = getMouseChild()
  mouseDev?.sendButton('UP')
}

def down() {
  logger("debug", "down()")
  def mouseDev = getMouseChild()
  mouseDev?.sendButton('DOWN')
}

def left() {
  logger("debug", "left()")
  def mouseDev = getMouseChild()
  mouseDev?.left()
}

def right() {
  logger("debug", "right()")
  def mouseDev = getMouseChild()
  mouseDev?.right()
}

def myApps() {
  logger("debug", "myApps()")
  sendWebosCommand(uri: 'system.launcher/launch', payload: [id: 'com.webos.app.discovery'])
}

def play() {
  logger("debug", "play()")
  sendWebosCommand(uri: "media.controls/play")
}

def pause() {
  logger("debug", "pause()")
  sendWebosCommand(uri: "media.controls/pause")
}

def home() {
  logger("debug", "home()")
  logger("debug", "home() - OLD Inputs: ${state.inputList} total length: ${state.toString().length()}")

  state.remove('serviceList')
  state.serviceList = []
  sendWebosCommand(uri: 'api/getServiceList', callback: { json ->
    logger("trace", "home() - getServiceList: ${json?.payload}")

    json?.payload?.services.each { service ->
      state.serviceList << service?.name
    }
    logger("info", "home() - Services: ${state.serviceList}")
  })
}

def sendCommand(cmd) {
  logger("debug", "sendCommand() - cmd: ${cmd?.inspect()}")

  def msg = String.format(cmd,state.sequenceNumber)
  logger("debug", "sendCommand() - msg: ${msg?.inspect()}")

  try {
    // send the command
    interfaces.webSocket.sendMessage(msg)
  } catch (Exception e) {
    logger("warn", "sendCommand() - Exception ${e}")
  }
  state.sequenceNumber++
}

def sendWebosCommand(Map params) {
  logger("debug", "sendWebosCommand() - params: ${params?.inspect()}")

  def id = params.id ?: ("command_" + state.sequenceNumber++)
  def cb = params.callback ?: { genericHandler(it) }
  def message_data = [
    'id': id,
    'type': params.type ?: "request",
  ]

  if (params.uri) {
    message_data.uri = "ssap://" + params.uri
  }

  if (params.payload) {
    message_data.payload = params.payload
  }

  def json = JsonOutput.toJson(message_data)
  logger("debug", "sendWebosCommand() - Sending: ${json} storing callback: ${id}")

  callbacks[id] = cb
  interfaces.webSocket.sendMessage(json)
  logger("debug", "sendWebosCommand() - Sending json: ${json}")
}

private void parseStatus(state, json) {
  logger("debug", "parseStatus() - state: ${state?.inspect()}, json: ${json?.inspect()}")

  def rResp = false
  if ((state.power == "off") && !(json?.payload?.subscribed == true)) {
    // when TV has indicated power off, do not process status messages unless they are subscriptions
    logger("debug", "parseStatus() - ignoring unsubscribed status updated during power off... message: ${json}")
    return
  }

  if (json?.payload?.returnValue == true) {
    // The last (valid) message sent by the TV when powering off is a subscription response for foreground app status with appId, windowId and processID all NULL
    if (json?.payload?.subscribed) {
      logger("debug", "parseStatus() - appID: "+ (description.contains("appId")?"T":"F") +", windowId: "+ (description.contains("windowId")?"T":"F") +", processId: "+ (description.contains("processId")?"T":"F"))

      if (description.contains("appId") && description.contains("windowId") && description.contains("processId")) {
        if ((json?.payload?.appId == null) || (json?.payload?.appId == "")) {
          // The TV is powering off - change the power state, but leave the websocket to time out
          powerEvent("off", "physical")
          logger("info", "Received POWER DOWN notification")
        }
      }
    }
  }
}


/**
 * @param level Level to log at, see LOG_LEVELS for options
 * @param msg Message to log
 */
private logger(level, msg) {
  if (level && msg) {
    Integer levelIdx = LOG_LEVELS.indexOf(level)
    Integer setLevelIdx = LOG_LEVELS.indexOf(logLevel)
    if (setLevelIdx<0) {
      setLevelIdx = LOG_LEVELS.indexOf(DEFAULT_LOG_LEVEL)
    }
    if (levelIdx<= setLevelIdx) {
      log."${level}" "${device.displayName} ${msg}"
    }
  }
}