superStateApp.groovy

/**
 *  superState	1.1
 *
 *  Copyright 2015 Mike Maxwell
 *  
 *  Device (switch/dimmer/color) state capture and replay utility.
 *  - resulting scene is assigned to a child device
 *  - scene devices are editable post capture (recapture/add/delete)
 *
 *
 *  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.
 *
 */
definition(
	name: "superState",
	namespace: "mmaxwell",
	author: "Mike Maxwell",
	description: "Device state capture, replay and edit tool",
	category: "Convenience",
	iconUrl: "https://s3.amazonaws.com/smartapp-icons/ModeMagic/Cat-ModeMagic.png",
	iconX2Url: "https://s3.amazonaws.com/smartapp-icons/ModeMagic/Cat-ModeMagic@2x.png",
	iconX3Url: "https://s3.amazonaws.com/smartapp-icons/ModeMagic/Cat-ModeMagic@3x.png"
)

preferences {
	page(name: "main")
	page(name: "group")
	page(name: "scene",nextPage	: "main")
	//page(name: "delete",nextPage: "main")
}

def main(){
	def nextGroupIDX = getNextGroupIDX()
	def nextGroupID = "g${nextGroupIDX}"
	//log.debug "mainPage- nextGroupIDX:${nextGroupIDX} nextGroupID:${nextGroupID}" 
	dynamicPage(name: "main", title: "superState", uninstall: true,install: true) {
		section("Device groups"){
			def prefGroups = getGroupMaps()
			prefGroups.each(){ prefGroup ->
				 href(
					name		: prefGroup.key
					,title		: prefGroup.value 
					,required	: false
					,params		: [groupID:prefGroup.key]
					,page		: "group"
					,description: null
					,state		: isGroupComplete(prefGroup.key)
				)
			}
		}
		section(){
			//always have a link for adding a new group
			href(
				name		: nextGroupID
				,title		: "Add a device group..." 
				,required	: false
				,params		: [groupID:nextGroupID]
				,page		: "group"
				,description: null
			)
		}
	}
}

def group(params){
	//log.debug "groupPage- params:${params} state:${state.groupID}"

	//account for different paths between android and ios
	def groupID //= params.groupID ?: params.params.groupID

	if (params.groupID) {
		groupID = params.groupID
	} else if (params.params) {
	groupID = params.params.groupID
	} else {
		groupID = state.groupID
	}
    
	def switchID = groupID + "dswitches" 
	def lockID = groupID + "dlocks"
	def relayID = groupID + "drelays"
	def valveID = groupID + "dvalves"
	def doorID = groupID + "ddoors"

	def nextSceneIDX = getNextSceneIDX(groupID)
	def nextSceneID = "${groupID}s${nextSceneIDX}"
	
	//log.debug "groupPage- groupID:${groupID} sceneID:${nextSceneID}"

	dynamicPage(name: "group", title: getGroupPageTitle(groupID), uninstall: false,install: false) {
	//dynamicPage(name: "group", title: "title", uninstall: false,install: false) {
		section() {
			input(
				name			: groupID
				,title			: "Group Name"
				,multiple		: false
				,required		: true
				,type			: "text"
            )
         }
        section("Scenes"){
			def prefScenes = getSceneMaps(groupID)
			prefScenes.each(){ prefScene ->
				href(
					name		: prefScene.key
					,title		: prefScene.value
					,required	: false
					,params		: [sceneID:prefScene.key,groupID:groupID]
					,page		: "scene"
					,state		: "complete"
					,description: null
				)
			}
		}
		//need to skip this section if groupID.value is null
		//some bug here if we create a scene before the group is saved
		//log.debug "settings on group page:${settings}"
		if (settings[groupID]){
			section(){
			//always have a link for adding a new scene
			href(
				name		: nextSceneID
					,title		: "Add a Scene..." 
					,required	: false
					,params		: [sceneID:nextSceneID,groupID:groupID]
					,page		: "scene"
					,description: null
				)  
			} 
		}
		section("Devices"){
			input(
				name			: switchID
				,title			: "Switches"
				,multiple		: true
				,required		: false
				,type			: "capability.switch"
			)
			/*
			input(
				name			: relayID
				,title			: "Relays"
				,multiple		: true
				,required		: false
				,type			: "capability.relayswitch"
			)
			input(
				name			: lockID
				,title			: "Locks"
				,multiple		: true
				,required		: false
				,type			: "capability.lock"
			)
			input(
				name			: valveID
				,title			: "Valves"
				,multiple		: true
				,required		: false
				,type			: "capability.valve"
			)
			input(
				name			: doorID
				,title			: "Doors"
				,multiple		: true
				,required		: false
				,type			: "capability.doorcontrol"
			)
			*/
		}
	}
}
def scene(params){
	try {
		//log.debug "scenePage- params:${params}" // state:${state.groupID}"
		//account for different paths between android and ios
		def sceneID = params.sceneID ?: params.params.sceneID
		def groupID = params.groupID ?: params.params.groupID
		state.groupID = groupID
		//log.debug "scenePage- params:${params} state:${state.groupID}"
		dynamicPage(name: "scene", title: getSceneTitle(sceneID), install: false) {
			section() {
				input(
					name		: sceneID
					,type		: "text"
					,title		: "Name for this Scene..."
					,required	: true
				)
			}
		}
	}
	catch (all) {
		//log.debug "boom..."
	}
}

def installed() {
	state.deviceMaps = [:]
	state.vtMaps = [:]
	//log.debug "Installed with settings: ${settings}"
}

def updated() {
	//log.debug "Updated with settings: ${settings}"
	unsubscribe()
	manageChildDevices()
	def sceneSwitches = getChildDevices()
	subscribe(sceneSwitches,"switch",cmdHandler)
	//remove stale device maps...
	cleanDeviceMaps()    
	//log.debug "deviceMaps:${state.deviceMaps}"
	//log.debug "settings:${settings}"
	//log.debug "vtMaps:${state.vtMaps}"

}
def cleanDeviceMaps(){
	//loop though device maps, remove those not in in device groups
	def allDeviceIDs  = []
	def groupIDs = getGroupMaps()
	//log.debug "test:${getDeviceKeysFromGroup("g1")}"
	groupIDs.each{ groupID ->
		def deviceKeys = getDeviceKeysFromGroup(groupID.key)
		//log.debug "devicesKeys:${deviceKeys}"
		deviceKeys.each{ deviceKey ->
			//log.debug "stDevices:${this[deviceKey]}"	
			def stDevices = this[deviceKey]
			stDevices.each{ stDevice ->
				allDeviceIDs.push(stDevice.id)
				//log.debug "~~~~${stDevice.id}~~~~"
			}
		}
	}
	//log.debug "stDevices:${allDeviceIDs}"
	def toRemove = []
	state.deviceMaps.each{ deviceMap ->
		//log.debug "device:${deviceMap.key}"	
		if (!allDeviceIDs.contains(deviceMap.key)){
			//state.deviceMaps.remove(deviceMap.key)
			//log.debug "remove me:${deviceMap.key}"
			toRemove.push(deviceMap.key)
		}
	}
	//log.debug "remove these:${toRemove}"
	toRemove.each{ it ->
		state.deviceMaps.remove(it)
	}

}

/**************											****************
virtual child device switch to scene mappings
state.vtMaps 	[virtualChildDevice.Id:sceneID]

[2ef9cc26-c9c6-4445-bac9-59457f194f88:g1s2,.....]


scene device to scene and settings mappings
state.deviceMaps [deviceMap,deviceMap,...]
deviceMap [deviceID:[name:deviceName,old:[settingsMap],scenes:[sceneMap,sceneMap,...]]
sceneMap [sceneID:[settingsMap]]
settingsMap [attribute:value,attribute:value,...]

[9b5c043e-ede1-443f-a245-33095e548a4e:[old:[switch:null], scenes:[g1s2:[switch:on], g1s1:[switch:on]], name:Pantry Lights]],...]

***************											***************/
def manageChildDevices(){
	def newVs
	def networkID
	def vTileName
	def vTileLabel
	def deviceID
	def uiGroups = getGroupMaps()
	//need to loop through all groups, then each scene
	uiGroups.each{ group ->
		def scenes = getSceneMaps(group.key)
		//log.debug "makechild Group:${group.key}"
		//log.debug "makechild scenes:${scenes}"
		scenes.each{ scene ->
			//log.debug "makechild scene:${scene.key}"
			if (!state.vtMaps.containsValue(scene.key)) {
				//log.debug "missing:${scene.key} ${scene.value}"
				networkID = app.id + "/" + scene.key
				vTileName = "${group.key}-${scene.key}"
				vTileLabel = "${group.value}-${scene.value}"
				newVs = addChildDevice("mmaxwell", "superState switch", networkID, null, [name: "${vTileName}", label: "${vTileLabel}", completedSetup: true])
				deviceID = newVs.id
				state.vtMaps << [(deviceID):scene.key]
			} else {
				//log.debug "vs exists already"
			}
		}
	}
	//now go thhrough vtMaps, remove any children not in settings
	//vt:2ef9cc26-c9c6-4445-bac9-59457f194f88=g1s2 should be deleted

	state.vtMaps.each{ it ->
		log.debug "vsm:${it}"
		if (!settings.containsKey(it.value)){
			log.debug "vt:${it} should be deleted"
			//won't let me delete..., says in use???
			//networkID = app.id + "/" + it.value
			//deleteChildDevice(networkID)
		}
	}
	//log.debug "vtMaps:${state.vtMaps}"
}

def cmdHandler(evt){
	def sceneID = state.vtMaps[evt.deviceId]
	def nid = app.id + "/" + sceneID
	def cmd = evt.data.split("~")[1]
	def logInfo = true
	def stateMapsOK = true
	if (logInfo) log.info "cmdHandler- scene:${sceneID} name:${evt.name} value:${evt.value}  cmd:${cmd}"
	//log.debug "cmdHandler- state.deviceMaps:${state.deviceMaps}"
	
	//events to ignore
	if (cmd in ["warn","override"]) return
	
	def isOverride = false
	def sceneSwitches = getChildDevices()
	def callingSwitch = getChildDevice(nid)
	//check if other scene switches are activeted
	sceneSwitches.each{ sceneSwitch ->
		//log.debug "cmdHandler - sceneSwitch:${sceneSwitch.name} value:${sceneSwitch.currentValue("switch")} evtName:${evt.deviceId}"  
		if (sceneSwitch.currentValue("switch") != "off" &&  sceneSwitch.id != evt.deviceId){
			sceneSwitch.overrideScene()
			isOverride = true
			if (logInfo) log.info "cmdHandler- override request from ${evt.displayName} to ${sceneSwitch.displayName}"
		}
	}

	if (evt.value == "on" && cmd == "snap"){
		if (logInfo) log.info "cmdHandler- ${sceneID} snap request"
		sceneSnap(sceneID,true)
		callingSwitch.off()
		return
	}

	if (evt.value == "on" && isOverride){
		if (logInfo) log.info "cmdHandler- ${sceneID} on with ignore snap request"
		stateMapsOK = setScene(sceneID,true,false)
		//return
	} else
	if (evt.value == "on"){
		if (logInfo) log.info "cmdHandler- ${sceneID} on request"
		sceneSnap(sceneID,false)
		stateMapsOK = setScene(sceneID,true,false)
		//return
	} else
	if (evt.value == "off" && cmd == "restore"){
		if (logInfo) log.info "cmdHandler- ${sceneID} off with restore request"
		stateMapsOK = setScene(sceneID,false,true)
		//return
	} else
	if (evt.value == "off"){
		if (logInfo) log.info "cmdHandler- ${sceneID} off request"
		setScene(sceneID,false,false)
		//return
	} else log.debug "last man standing"

	if (!stateMapsOK){
		log.warn state.mapsCheck.replace("sceneSwitchName",evt.displayName)
		callingSwitch.warn()
	}
}

def setScene(sceneID,turnOn,restore){
	//if turnOn == false and restore == true, we reset the state to old
	//if turnOn == false and restore == false, then just turn everything off...
	//if turnOn == true, we turn on the scene, restore doesn't matter

	//log.debug "setScene sceneID:${sceneID} turnOn:${turnOn} restore:${restore}"
	def sceneMap = [:]
	def savedMap
	def deviceMap = [:]
	def deviceKeys = getDeviceKeysFromScene(sceneID) //represents list of devices included in this group
	def hasDevices = deviceKeys.size() != 0
	def success = true
	def missingDevices = []
	state.mapsCheck = ""
	def logInfo = false
	if (hasDevices){
		deviceKeys.each{ deviceKey ->
			def groupDevices = this[deviceKey] //devices in this group from prefs
			groupDevices.each{ stDevice ->
				deviceMap = state.deviceMaps[stDevice.id]
				if (deviceMap != null){
					sceneMap = deviceMap.scenes[sceneID] 
					if (sceneMap != null){
						if (restore){
							savedMap = deviceMap.old
							//
							def crntEqualsSaved = true
							def crntEqualsScene = true
							//log.debug "${stDevice.displayName}: saved:${savedMap} scene:${sceneMap}"
							sceneMap.each{ attribute ->
								def crntValue = stDevice.currentValue(attribute.key).toString()
								//log.debug "current- attr:${attribute.key} value:${crntValue}"
								//log.debug "attr:${attribute.key} crnt:${crntValue} save:${savedMap[attribute.key].value} scene:${attribute.value}"

								if (attribute.value.toString() != crntValue){
									//log.debug "NEQ scene attr:[${attribute.value}][${crntValue}]"
									if (crntEqualsScene){
										//log.debug "set false"
										crntEqualsScene = false
									}
								}
								//def savedAttribute = savedMap[attribute.key]
								if ("${savedMap[attribute.key].value}" != crntValue){
									//log.debug "NEQ save attr:[${savedMap[attribute.key].value}][${crntValue}]"
									if (crntEqualsSaved){
										//log.debug "set false"
										crntEqualsSaved = false
									}
								}
							}
							//log.debug "${stDevice.displayName}: crntEqualsSaved:${crntEqualsSaved} crntEqualsScene:${crntEqualsScene}" 
						}
            			if (turnOn){
							// scene on request            
							if (logInfo) log.info "scene on request for ${sceneID} ${stDevice.displayName}"
							//this device goes on
							if (sceneMap.switch == "on"){
								//RGBW
								if (sceneMap.whiteLevel) {
									//log.debug "RGBW detected, map:${sceneMap}"
									stDevice.on()
									def colorMap = [hex:sceneMap.color,level:sceneMap.level]
									stDevice.setColor(colorMap)
									stDevice.setWhiteLevel(sceneMap.whiteLevel)
									log.debug "RGBW:${stDevice.displayName}, ON"
								//color
								} else if (sceneMap.color) {
									stDevice.on()
									def colorMap = [hue:sceneMap.hue.toInteger(),saturation:sceneMap.saturation.toInteger(),level:sceneMap.level]
									stDevice.setColor(colorMap)  
									log.debug "color:${stDevice.displayName}, ON"
								//dimmer
								} else if (sceneMap.level){
									stDevice.setLevel(sceneMap.level)	
									log.debug "dimmer:${stDevice.displayName}, ON"
								//switch    
								} else {
									stDevice.on()
									log.debug "switch:${stDevice.displayName}, ON"
												}
							//this device goes off
							} else {
								stDevice.off()
								log.debug "${stDevice.displayName}, OFF"
							}
						} else {
							if (restore){
								// scene off request with restore
								if (logInfo) log.info "scene off request with restore for ${sceneID} ${stDevice.displayName}"
									//replace with restore code
									stDevice.off()
								} else {
									//scene off request
									if (logInfo) log.info "scene off request for ${sceneID} ${stDevice.displayName}"
									stDevice.off()
								}
						}
					} else {
						log.debug "setScene- sceneMap is null????"
						success = false
					}
				} else {
					//log.debug "setScene- no scene snapped stDevice:${stDevice.displayName}"
					missingDevices.push(stDevice.displayName)
					success = false
				}
			}//group device loop
		}//device keys loop
		if (!success) state.mapsCheck = "Device(s):${missingDevices.toListString()} for scene 'sceneSwitchName' have not been snapped, please re-snap the scene."                    
	//no devices        
	} else {
		log.debug "setScene- no devices"
		state.mapsCheck = "No devices are selected for device group '${getGroupDisplayNameFromScene(sceneID)}', select your devices and snap a scene."                    
		success = false
	}
	return success
}

def sceneSnap(sceneID,isNew) {
	def attributesToSave = ['hue', 'saturation', 'color', 'switch', 'level', "whiteLevel"]
	//def attributesToSave = ['color', 'switch', 'level']
	def allAttributes = []
	def savedMap
	def newMap
	def dataMap
	def deviceMap
	def sceneMap
	def deviceKeys = getDeviceKeysFromScene(sceneID)
	//initial snapshot
	if (isNew){
		deviceKeys.each{ deviceKey ->
			//log.debug "deviceKey:${deviceKey}"
			def groupDevices = this[deviceKey]
			//log.debug "groupDevices:${groupDevices}"
			groupDevices.each{ stDevice ->
				//log.debug "stDevice:${stDevice}"	
				allAttributes = stDevice.supportedAttributes.collect{it.toString()}
				newMap = [:]
				savedMap = [:]
				deviceMap = [:]
				dataMap = [:]
				sceneMap = [:]
				//check if device has a device map
				if (!state.deviceMaps.containsKey(stDevice.id)){
					//log.debug "add device:${stDevice.id} and scene:${sceneID}"
					allAttributes.each {attribute ->
						if (attributesToSave.contains(attribute)){
							newMap << [(attribute):stDevice.currentValue(attribute)]
							savedMap << [(attribute):null]
						}
					}
					sceneMap = [(sceneID):newMap]
					dataMap = [name:stDevice.displayName, old:savedMap,scenes:sceneMap]
					deviceMap = [(stDevice.id):dataMap]
					state.deviceMaps << deviceMap
				} else {
					//does it have this scene?
					deviceMap = state.deviceMaps[stDevice.id]
					if (!deviceMap.scenes.containsKey(sceneID)){
						//log.debug "add scene:${sceneID} to device:${stDevice.id}"
						allAttributes.each {attribute ->
							if (attributesToSave.contains(attribute)){
								newMap << [(attribute):stDevice.currentValue(attribute)]
							}
						}
						sceneMap = [(sceneID):newMap]
						deviceMap.scenes << sceneMap
					} else {
						//resnap settings here
						//log.debug "resnap for device:${stDevice.id} scene:${sceneID}"
						sceneMap = deviceMap.scenes[sceneID]
						allAttributes.each {attribute ->
							if (attributesToSave.contains(attribute)){
								sceneMap[attribute] = stDevice.currentValue(attribute)
							}
						}
					}
				}
			}
		}
	//snapshot used to save previous state
	} else {
		//specific device map
		//9b5c043e-ede1-443f-a245-33095e548a4e:[old:[switch:null], scenes:[g1s2:[switch:on], g1s1:[switch:on]], name:Pantry Lights]] 
		//save previous state
		deviceKeys.each{ deviceKey ->
			def groupDevices = this[deviceKey]
			groupDevices.each{ stDevice ->
				//old:[level:null, saturation:null, color:null, hue:null, switch:null]
				deviceMap = state.deviceMaps[stDevice.id]
				if (deviceMap != null){
					savedMap = deviceMap.old
					savedMap.each{ attribute ->
						deviceMap.old[attribute.key] = stDevice.currentValue(attribute.key) 
					}
				}
			}
		}
		//log.debug "sceneSnap- ${sceneID} savedMap:${savedMap}"
	}
	//log.debug "sceneSnap ${sceneID} isNew:${isNew}"
	//log.debug "state.deviceMaps:${state.deviceMaps}"
}

/**********************************************
UI preference settings methods
***********************************************/
def isGroupComplete(groupID){
	def boolean hasScenes = getSceneMaps(groupID) ?: false
	def boolean hasDevices = getDeviceLists(groupID) ?: false
	if (hasScenes && hasDevices) return "complete"
	else return "incomplete"
}

def getDeviceKeysFromGroup(groupID){
	return settings.findAll(){it.key ==~ /${groupID}d[a-z,A-Z]+/}.keySet()
}

def getDeviceLists(groupID){
	// [g1:Master, g1s1:some Scene, g1dswitches:[AeonD11, Bar Strip]]
	//all device lists gxdxxxx
	return settings.findAll(){it.key ==~ /${groupID}d[a-z,A-Z]+/}
}
def getDeviceKeysFromScene(sceneID){
	//get group from scene
	def groupID = sceneID.replaceFirst(/s[0-9]+/,"")
	return settings.findAll(){it.key ==~ /${groupID}d[a-z,A-Z]+/}.keySet()
}

def getGroupDisplayNameFromScene(sceneID){
	def groupID = sceneID.replaceFirst(/s[0-9]+/,"")
	return settings[groupID]
}
def getSceneDisplayNameFromScene(sceneID){
	return settings[sceneID]
}

def getGroupPageTitle(groupID){
	return settings[groupID] ?: "Device Group ${groupID.replace("g","")}"
}

def getSceneTitle(sceneID){
	return settings[sceneID] ?: sceneID.replace("g","Group ").replace("s",", Scene ") 
}

def getGroupMaps(){
	return settings.findAll(){it.key ==~ /g[0-9]+/}.sort{it.key}
}

def getSceneMaps(groupID){
	//scene key format : g1s1
	return settings.findAll(){it.key ==~ /${groupID}s[0-9]+/}.sort{it.key}
}

def getNextGroupIDX(){
	def found = settings.findAll(){it.key ==~ /g[0-9]+/}
	def next = 0
	def crnt
	found.each(){ it.key
		crnt = it.key.replace("g","").toInteger()
		if (crnt > next ) next = crnt
	}
	next ++
	//log.debug "getNext:${next}"
	return next
}

def getNextSceneIDX(groupID){
	def found = settings.findAll(){it.key ==~ /${groupID}s[0-9]+/}
	def next = 0
	def crnt
	found.each(){ it.key
		crnt = it.key.replace("${groupID}s","").toInteger()
		if (crnt > next ) next = crnt
	}
	next ++
	return next
}