import org.openhab.core.library.types.*
import org.openhab.core.persistence.*
import org.openhab.model.script.actions.*
import org.joda.time.*
import java.util.Random
import java.util.Date
import java.util.TimeZone
import java.text.SimpleDateFormat
import org.quartz.TriggerBuilder.*
import org.quartz.CronScheduleBuilder.*
import org.quartz.DateBuilder.*
var Timer stopptanz_firsttimer = null
var Timer stopptanz_secondtimer = null
var Timer stopptanz_thirdtimer = null
//
rule "Turn On Effektlicht when Bose turns on to TV at evening"
when
//	Item So received update
	Item WZ_Soundtouch300_Source changed to TV
then
	        if (now.getHourOfDay() >= 20 || now.getHourOfDay() <= 1) {
			sendCommand(Wohnzimmer_Effektlicht, ON)
		}
end

rule "Powerupdate - Member of Group changed its powerstate"
when
        Member of gSoundtouch_Source changed from "STANDBY"
then
//	logInfo("Soundtouch: Member of Soundtouch_Source changed from STANDBY", "Member: " + triggeringItem.name)
        //initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_Power = devicename + "_Power"
        val devicename_AvailableForMultiroom = devicename + "_AvailableForMultiroom"
        val devicename_AvailableForMaster = devicename + "_AvailableForMaster"
        val devicename_MAC = devicename + "_MAC"
        val devicename_Master = devicename + "_Master"
        val devicename_Multiroom = devicename + "_Multiroom"
        val devicename_Multiroom_item = gSoundtouch_Multiroom.members.findFirst[ d | d.name == devicename_Multiroom ]
        val devicename_Master_item = gSoundtouch_Master.members.findFirst[ d | d.name == devicename_Master ]
        val devicename_Power_item = gSoundtouch_Power.members.findFirst[ d | d.name == devicename_Power ]
        val devicename_AvailableForMultiroom_item = gSoundtouch_AvailableForMultiroom.members.findFirst[ d | d.name == devicename_AvailableForMultiroom ]
        val devicename_AvailableForMaster_item = gSoundtouch_AvailableForMaster.members.findFirst[ d | d.name == devicename_AvailableForMaster ]
        val devicename_MAC_item = gSoundtouch_MAC.members.findFirst[ d | d.name == devicename_MAC ]
        val Number MACPlaying = gSoundtouch_MacPlaying.members.filter[ NumberItem i | i.state!="" ].size
        val Number MastersCount = gSoundtouch_Master.members.filter[ NumberItem i | i.state==ON ].size

//        logInfo("Soundtouch: Member of Soundtouch_Source changed from STANDBY", "Power_item ON: " + devicename_Power_item.name )
	postUpdate(devicename_Power_item, ON)
	// Add speaker to Master if only one Master exists - Feature for automatically adding speakers to Multiroom when turned on
	if(MastersCount==1 && triggeringItem.state!="AIRPLAY" || Soundtouch_Multiroom_Master.state!="" && MastersCount==0 && triggeringItem.state!="AIRPLAY"){
//      logInfo("Soundtouch: Member of Soundtouch_Source changed from STANDBY", "Add speaker to Master if only one Master exists - Feature for automatically adding speakers to Multiroom when turned on. Multiroom ON: " + devicename_Multiroom_item.name )
		sendCommand(devicename_Multiroom_item,ON)
	}	
//        logInfo("Soundtouch: Member of Soundtouch_Source changed from STANDBY", "Available For Master OFF: " + devicename_AvailableForMaster_item.name )
	postUpdate(devicename_AvailableForMaster_item,OFF)
end

rule "Powerupdate - Member of Group changed its powerstate to STANDBY"
when
        Member of gSoundtouch_Source changed to "STANDBY"
then

//        logInfo("Soundtouch: Member of Soundtouch_Source changed to STANDBY", "Member: " + triggeringItem.name)
        //initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_Power = devicename + "_Power"
        val devicename_AvailableForMultiroom = devicename + "_AvailableForMultiroom"
        val devicename_AvailableForMaster = devicename + "_AvailableForMaster"
        val devicename_MAC = devicename + "_MAC"
        val devicename_Master = devicename + "_Master"
        val devicename_Multiroom = devicename + "_Multiroom"
        val devicename_Multiroom_item = gSoundtouch_Multiroom.members.findFirst[ d | d.name == devicename_Multiroom ]
        val devicename_Master_item = gSoundtouch_Master.members.findFirst[ d | d.name == devicename_Master ]
        val devicename_Power_item = gSoundtouch_Power.members.findFirst[ d | d.name == devicename_Power ]
        val devicename_AvailableForMultiroom_item = gSoundtouch_AvailableForMultiroom.members.findFirst[ d | d.name == devicename_AvailableForMultiroom ]
        val devicename_AvailableForMaster_item = gSoundtouch_AvailableForMaster.members.findFirst[ d | d.name == devicename_AvailableForMaster ]
        val devicename_MAC_item = gSoundtouch_MAC.members.findFirst[ d | d.name == devicename_MAC ]
        val Number MACPlaying = gSoundtouch_MacPlaying.members.filter[ NumberItem i | i.state!="" ].size
        val Number MastersCount = gSoundtouch_Master.members.filter[ NumberItem i | i.state==ON ].size

//        logInfo("Soundtouch: Member of Soundtouch_Source changed to STANDBY", "Currently Devices Playing: " +MACPlaying + "MastersCount: " + MastersCount)
//        logInfo("Soundtouch: Member of Soundtouch_Source changed to STANDBY", "Update Power Item to OFF:" + devicename_Power_item.name)      
        postUpdate(devicename_Power_item, OFF)
//        logInfo("Soundtouch: Member of Soundtouch_Source changed to STANDBY", "Remove Device from Playing Group:" + triggeringItem.name)
        gSoundtouch_MacPlaying.removeMember(devicename_MAC_item)
//        logInfo("Soundtouch: Member of Soundtouch_Source changed to STANDBY", "Turn of Master if exists and make unavailable for Master :" + triggeringItem.name)
        postUpdate(devicename_AvailableForMaster_item,NULL)
        postUpdate(devicename_Master_item,OFF)
	// Remove speaker from Multiroom when turned off
//        logInfo("Soundtouch: Member of Soundtouch_Source changed to STANDBY", "Remove Speaker from Multiroom, when Multiroom is on: " + triggeringItem.name)
        if(devicename_Multiroom_item.state==ON){
	        sendCommand(devicename_Multiroom_item,OFF)
	}
end
rule "PlayControl - Member of Group changed to Play"
when
	Member of gSoundtouch_Player changed
then
        //initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_MAC = devicename + "_MAC"
        val devicename_IP = devicename + "_IP"
        val devicename_Source = devicename + "_Source"
        val devicename_Source_item = gSoundtouch_Source.members.findFirst[ d | d.name == devicename_Source ]
        val devicename_MAC_item = gSoundtouch_MAC.members.findFirst[ d | d.name == devicename_MAC ]
        val devicename_IP_item = gSoundtouch_IP.members.findFirst[ d | d.name == devicename_IP ]
        val Number MastersCount = gSoundtouch_Master.members.filter[ NumberItem i | i.state==ON ].size

//        logInfo("Soundtouch: Member of gSoundtouchPlayer changed:", "MastersCount: " + MastersCount + " Multiroom_Master: " +Soundtouch_Multiroom_Master.state)
	if(triggeringItem.state==PLAY){
		if(devicename_Source_item.state!="PRODUCT"){
 //                       logInfo("New Playing Member:", "MAC:" +triggeringItem.name)
			gSoundtouch_MacPlaying.addMember(devicename_MAC_item)
		}
                if (MastersCount==0 && Soundtouch_Multiroom_Master.state=="" || Soundtouch_Multiroom_Master.state==NULL){
                        gSoundtouch_MacPlaying.members.filter[ NumberItem i | i.state!="" ].forEach[ i |
				postUpdate(Soundtouch_Multiroom_Master,i.state)
//				postUpdate(Soundtouch_Multiroom_Master_IP,i.state) ]
//                                postUpdate(Soundtouch_Multiroom_Master,devicename_MAC_item.state)
                                postUpdate(Soundtouch_Multiroom_Master_IP,devicename_IP_item.state) ]

//                        logInfo("New Master:", "MAC:" +Soundtouch_Multiroom_Master.state)
		}
	}
	else {
		gSoundtouch_MacPlaying.removeMember(devicename_MAC_item)
	}
end

rule "Powerupdate - Member of Group received Powercommand"
when
	Member of gSoundtouch_Power received command
then
//	logInfo("Soundtouch: Member of gSoundtouch_Power received command", "Member: " +triggeringItem.name)
        //initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
	val devicename_Power = devicename + "_Power"
        val devicename_Power_item = gSoundtouch_Power.members.findFirst[ d | d.name == devicename_Power ]	
	val devicename_IP = devicename + "_IP"
        val devicename_IP_item = gSoundtouch_IP.members.findFirst[ d | d.name == devicename_IP ]
        val devicename_Source = devicename + "_Source"
        val devicename_Source_item = gSoundtouch_Source.members.findFirst[ d | d.name == devicename_Source ]
	val url = "http://" + devicename_IP_item.state + ":8090/key"
	val xmlstring = '<key state="press" sender="Gabbo">POWER</key>'

	if(receivedCommand==ON && devicename_Source_item.state=="STANDBY" || receivedCommand==OFF && devicename_Source_item.state!="STANDBY"){
		logInfo("Soundtouch: Member of gSoundtouch_Power received command", "receivedCommand ON, Source Standby OR OFF and Source not Standby")
	        logInfo("Soundtouch: Member of gSoundtouch_Power received command","Power for: " +devicename + " "+ devicename_IP_item + "receivedCommand: " + receivedCommand)
		sendHttpPostRequest(url , "application/xml", xmlstring)
	}
//	logInfo("Powertrigger","Power for: " +devicename + " "+ devicename_IP_item + "receivedCommand: " + receivedCommand)
//        logInfo("Soundtouch: Member of gSoundtouch_Power received command", "Update Poweritem after pressing ON:" +devicename_Power_item.name)
	postUpdate(devicename_Power_item,receivedCommand)
	
end
rule "Multiroom - Member of Group becomes master"
when
        Member of gSoundtouch_AvailableForMaster changed to ON
then
//        logInfo("Soundtouch: Member of gSoundtouch_AvailableForMaster changed to ON", "Member: " +triggeringItem.name)
        //initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_AvailableForMultiroom = devicename + "_AvailableForMultiroom"
        val devicename_Master = devicename + "_Master"
        val devicename_Multiroom = devicename + "_Multiroom"
        val devicename_MAC = devicename + "_MAC"
        val devicename_AvailableForMaster = devicename + "_AvailableForMaster"
        val devicename_AvailableForMultiroom_item = gSoundtouch_AvailableForMultiroom.members.findFirst[ d | d.name == devicename_AvailableForMultiroom ]
        val devicename_AvailableForMaster_item = gSoundtouch_AvailableForMaster.members.findFirst[ d | d.name == devicename_AvailableForMaster ]
        val devicename_Master_item = gSoundtouch_Master.members.findFirst[ d | d.name == devicename_Master ]
        val devicename_MAC_item = gSoundtouch_MAC.members.findFirst[ d | d.name == devicename_MAC ]
        val devicename_Multiroom_item = gSoundtouch_Multiroom.members.findFirst[ d | d.name == devicename_Multiroom ]
        val devicename_IP = devicename + "_IP"
        val devicename_IP_item = gSoundtouch_IP.members.findFirst[ d | d.name == devicename_IP ]

  //      logInfo("ChangeToMaster","ChangeToMaster: " + devicename_AvailableForMaster_item)
  //      logInfo("Soundtouch: Member of gSoundtouch_AvailableForMaster changed to ON", " Update to Master: " +triggeringItem.name + " Write to Multiroom_Master: " + +triggeringItem.name + " Write Master IP to: " +triggeringItem.name + " Turn on Multiroom on For :" +triggeringItem.name + " Not Available for Multiroom anymore: " + triggeringItem.name)
        sendCommand(devicename_Multiroom_item,OFF)
	postUpdate(devicename_AvailableForMaster_item,ON)
        postUpdate(Soundtouch_Multiroom_Master,devicename_MAC_item.state)
        postUpdate(Soundtouch_Multiroom_Master_IP,devicename_IP_item.state)
        postUpdate(devicename_Master_item,ON)
        sendCommand(devicename_Multiroom_item,ON)
        postUpdate(devicename_AvailableForMultiroom_item,OFF)
end

rule "Multiroom - Member of Group ends master"
when
        Member of gSoundtouch_AvailableForMaster changed to OFF
then
//	logInfo("Masterend","Master end: " + triggeringItem.name)
end

rule "Bose - Volume Up"
when
	Member of gSoundtouch_VolumeUp changed to ON
then
        //initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_VolumeUp = devicename + "_VolumeUp"
        val devicename_VolumeUp_item = gSoundtouch_VolumeUp.members.findFirst[ d | d.name == devicename_VolumeUp ]
        val devicename_Volume = devicename + "_Volume"
        val devicename_Volume_item = gSoundtouch_Volume.members.findFirst[ d | d.name == devicename_Volume ]
        val currentvol = devicename_Volume_item.state as Number
        val setvol = currentvol + 5

        sendCommand(devicename_Volume_item, setvol)
        postUpdate(devicename_VolumeUp_item, OFF)
end
//
rule "Bose - Volume Down"
when
        Member of gSoundtouch_VolumeDown changed to ON
then
        //initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_VolumeDown = devicename + "_VolumeDown"
        val devicename_VolumeDown_item = gSoundtouch_VolumeDown.members.findFirst[ d | d.name == devicename_VolumeDown ]
        val devicename_Volume = devicename + "_Volume"
        val devicename_Volume_item = gSoundtouch_Volume.members.findFirst[ d | d.name == devicename_Volume ]
        val currentvol = devicename_Volume_item.state as Number
        val setvol = currentvol - 5

        sendCommand(devicename_Volume_item, setvol)
        postUpdate(devicename_VolumeDown_item, OFF)
end

rule "Bose - Volume Limit"
when
        Member of gSoundtouch_Volume changed
then
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_Volume = devicename + "_Volume"
        val devicename_Volume_item = gSoundtouch_Volume.members.findFirst[ d | d.name == devicename_Volume ]

	if(devicename_Volume_item.state>50){
		sendCommand(devicename_Volume_item, 30)
	}
end

rule "Stopptanz Soundtouch10 Küche"
when
    Item Kueche_Soundtouch10_Stopptanz changed from OFF to ON
then
        stopptanz_thirdtimer = null
	var i = 0
	stopptanz_thirdtimer = createTimer(now.plusSeconds(900),  [ |
        if (stopptanz_thirdtimer!=null)
	{    
		i=1
	}
	])
	stopptanz_firsttimer = null
	stopptanz_secondtimer = null
	while(i != 1 ) {
		var int stopptanz_StopRandom = 1+(Math::random * 30.0).intValue
	        var int stopptanz_PlayRandom = 3+(Math::random * 9.0).intValue
		if (stopptanz_firsttimer==null)
	        {
//	                logInfo("FILE", "stopptanz_StopRandom : " + stopptanz_StopRandom + "stopptanz_PlayRandom : " + stopptanz_PlayRandom )
	                stopptanz_firsttimer = createTimer(now.plusSeconds(stopptanz_StopRandom),  [ |
//		        logInfo("FILE", "stop")
			sendCommand(Kueche_Soundtouch10_PlayerControl, PAUSE)
			stopptanz_secondtimer = createTimer(now.plusSeconds(stopptanz_PlayRandom),  [ |
			if (stopptanz_secondtimer!=null)
			{
//				logInfo("FILE", "play")
		                sendCommand(Kueche_Soundtouch10_PlayerControl, PLAY)
			        stopptanz_firsttimer = null
			        stopptanz_secondtimer = null
			}
			])

		
		])
		}
		if (Kueche_Soundtouch10_Stopptanz.state==OFF || Kueche_Soundtouch10_Power.state==OFF)
		{
			i=1
		}
	}
end

rule "Multiroom ON - Member of Group received Multiroom ON"
when
	Member of gSoundtouch_Multiroom received command ON
then
        //initialize variables from all needed groups 
	val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_Power = devicename + "_Power"
        val devicename_AvailableForMultiroom = devicename + "_AvailableForMultiroom"
        val devicename_AvailableForMaster = devicename + "_AvailableForMaster"
        val devicename_Power_item = gSoundtouch_Power.members.findFirst[ d | d.name == devicename_Power ]
        val devicename_AvailableForMultiroom_item = gSoundtouch_AvailableForMultiroom.members.findFirst[ d | d.name == devicename_AvailableForMultiroom ]
        val devicename_AvailableForMaster_item = gSoundtouch_AvailableForMultiroom.members.findFirst[ d | d.name == devicename_AvailableForMaster ]
	val devicename_MAC = devicename + "_MAC"
	val devicename_MAC_item = gSoundtouch_MAC.members.findFirst[ d | d.name == devicename_MAC ]
	val devicename_IP = devicename + "_IP"
	val devicename_IP_item = gSoundtouch_IP.members.findFirst[ d | d.name == devicename_IP ]
//	logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command ON", "Multiroom ON for device:" + devicename + " Master: " + Soundtouch_Multiroom_Master.state +  "Master_IP: " + Soundtouch_Multiroom_Master_IP.state +" IP: " + devicename_IP_item.state)
	postUpdate(devicename_Power_item,ON)
        val url_client = "http://" + devicename_IP_item.state + ":8090/setZone"
        val url_master = "http://" + Soundtouch_Multiroom_Master_IP.state + ":8090/setZone"
        val xmlstring_client = '<zone master="' + Soundtouch_Multiroom_Master.state + '" senderIPAddress="' + Soundtouch_Multiroom_Master_IP.state + '" senderIsMaster="true">"<member ipaddress="' + devicename_IP_item.state +'">' + devicename_MAC_item.state +'</member></zone>'
	val xmlstring_master = '<zone master="' + Soundtouch_Multiroom_Master.state + '" senderIPAddress="' + Soundtouch_Multiroom_Master_IP.state + '"><member ipaddress="' + devicename_IP_item.state +'">' + devicename_MAC_item.state +'</member></zone>'
	sendHttpPostRequest(url_client , "application/xml", xmlstring_client)
        logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command ON", "Xml String für Client:" + xmlstring_client)
        sendHttpPostRequest(url_master , "application/xml", xmlstring_master)
//        logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command ON", "Xml String für Master:" + xmlstring_master)
//        logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command ON", "AvailableForMultiroom OFF: "+ triggeringItem.name + " AvailableForMaster: NULL: " +triggeringItem.name )
	postUpdate(devicename_AvailableForMultiroom_item,OFF)
        postUpdate(devicename_AvailableForMaster_item,NULL)

end
rule "Multiroom OFF - Member of Group received Multiroom OFF"
when
        Member of gSoundtouch_Multiroom received command OFF
then
//	logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command OFF", "Member: " +triggeringItem.name)
	//initialize variables from all needed groups 
        val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
        val devicename_Multiroom = devicename + "_Multiroom"
        val devicename_AvailableForMultiroom = devicename + "_AvailableForMultiroom"
        val devicename_AvailableForMaster = devicename + "_AvailableForMaster"
        val devicename_MultiroomMaster = devicename + "_MultiroomMaster"
        val devicename_Multiroom_item = gSoundtouch_Multiroom.members.findFirst[ d | d.name == devicename_Multiroom ]
        val devicename_AvailableForMultiroom_item = gSoundtouch_AvailableForMultiroom.members.findFirst[ d | d.name == devicename_AvailableForMultiroom ]
        val devicename_AvailableForMaster_item = gSoundtouch_AvailableForMaster.members.findFirst[ d | d.name == devicename_AvailableForMaster ]
        val devicename_MultiroomMaster_item = gSoundtouch_MultiroomMaster.members.findFirst[ d | d.name == devicename_MultiroomMaster ]
        val devicename_IP = devicename + "_IP"
        val devicename_IP_item = gSoundtouch_IP.members.findFirst[ d | d.name == devicename_IP ]
	val url_getZoneString = 'http://' + devicename_IP_item.state + ':8090/getZone'
        val url_removeZoneSlave = 'http://' + devicename_IP_item.state + ':8090/removeZoneSlave'
	val getZoneString = sendHttpGetRequest(url_getZoneString)
	val getZoneString_parsed = "<" + getZoneString.split('<').get(2) +"<" + getZoneString.split('<').get(3) + "<" + getZoneString.split('<').get(4) + "<" + getZoneString.split('<').get(5)

//        logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command OFF", "Multiroom OFF for device:" + devicename + " Master: " + Soundtouch_Multiroom_Master.state)
//        logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command OFF", "Zonestring that will be removed:" + getZoneString_parsed)
        sendHttpPostRequest(url_removeZoneSlave , "application/xml", getZoneString_parsed)
//        logInfo("Soundtouch: Member of gSoundtouch_Multiroom received command OFF", "Multiroom OFF: " + triggeringItem.name + " AvailableForMultiroom ON: " + triggeringItem.name + " AvailableForMaster: NULL: " +triggeringItem.name )
        postUpdate(devicename_Multiroom_item,OFF)
        postUpdate(devicename_AvailableForMultiroom_item,ON)
        postUpdate(devicename_AvailableForMaster_item,NULL)
end

rule "Multiroom - MultiroomMaster changed in Group"
when
	Member of gSoundtouch_MultiroomMaster changed
then	
	val devicename = triggeringItem.name.toString.split('_').get(0) +"_" +triggeringItem.name.toString.split('_').get(1)
	val devicename_Power = devicename + "_Power"
	val devicename_Multiroom = devicename + "_Multiroom"
        val devicename_Master = devicename + "_Master"
        val devicename_AvailableForMaster = devicename + "_AvailableForMaster"
        val devicename_MultiroomMaster = devicename + "_MultiroomMaster"
        val devicename_AvailableForMultiroom = devicename + "_AvailableForMultiroom"
        val devicename_MAC = devicename + "_MAC"
        val devicename_Power_item = gSoundtouch_Power.members.findFirst[ d | d.name == devicename_Power ]
	val devicename_Multiroom_item = gSoundtouch_Multiroom.members.findFirst[ d | d.name == devicename_Multiroom ]
	val devicename_Master_item = gSoundtouch_Master.members.findFirst[ d | d.name == devicename_Master ]
	val devicename_AvailableForMaster_item = gSoundtouch_AvailableForMaster.members.findFirst[ d | d.name == devicename_AvailableForMaster ]
        val devicename_MultiroomMaster_item = gSoundtouch_MultiroomMaster.members.findFirst[ d | d.name == devicename_MultiroomMaster ]
        val devicename_AvailableForMultiroom_item = gSoundtouch_AvailableForMultiroom.members.findFirst[ d | d.name == devicename_AvailableForMultiroom ]
        val devicename_MAC_item = gSoundtouch_MAC.members.findFirst[ d | d.name == devicename_MAC ]
        val devicename_IP = devicename + "_IP"
        val devicename_IP_item = gSoundtouch_IP.members.findFirst[ d | d.name == devicename_IP ]
///////////ERROR//////////
//	//If Group is empty, it means no Multiroom is active. Reset any global items and set every soundtouch to available for multiroom
	if(gSoundtouch_MultiroomMaster.state==""){
//		logInfo("Soundtouch: Member of gSoundtouch_MultiroomMaster changed", "Group is empty, it means no Multiroom is active. Reset any global items and set every soundtouch to available for multiroom")
	        postUpdate(Soundtouch_Multiroom_Master,"")
	        postUpdate(Soundtouch_Multiroom_Master_IP,"")
	        sendCommand(gSoundtouch_AvailableForMultiroom, ON)
	}
        //If the new MultiroomMaster is the same as the Device, set the device as master 
	if (triggeringItem.state==devicename_MAC_item.state){
//                logInfo("Soundtouch: Member of gSoundtouch_MultiroomMaster changed", "new MultiroomMaster is the same as the Device, set the device as master")
		postUpdate(devicename_Master_item,ON)
                postUpdate(devicename_AvailableForMaster_item,NULL)
	}
	//If empty it means that the device does not belong to any multiroom group anymore -> update multiroom, master, availability
	if (triggeringItem.state==""){
//		logInfo("Soundtouch: Member of gSoundtouch_MultiroomMaster changed", "empty it means that the device does not belong to any multiroom group anymore -> update multiroom, master, availability")
                postUpdate(devicename_Multiroom_item,OFF)
                postUpdate(devicename_Master_item,OFF)
                postUpdate(devicename_AvailableForMultiroom_item,ON)
		if(devicename_Power_item.state==OFF){
//	                logInfo("Soundtouch: Member of gSoundtouch_MultiroomMaster changed", "AvailableForMaster NULL: " + triggeringItem.name)
	                postUpdate(devicename_AvailableForMaster_item,NULL)
		}
		else {
//                        logInfo("Soundtouch: Member of gSoundtouch_MultiroomMaster changed", "AvailableForMaster OFF: " + triggeringItem.name)
	                postUpdate(devicename_AvailableForMaster_item,OFF)
		}
	}
	//If not empty, update global variables
	else {
		val master_device_mac = gSoundtouch_MAC.members.findFirst[ d | d.state == devicename_MultiroomMaster_item.state ]
		val master_device_IP = master_device_mac.name.toString.split('_').get(0) +"_" +master_device_mac.name.toString.split('_').get(1) + "IP"
	        val master_device_IP_item = gSoundtouch_IP.members.findFirst[ d | d.name == master_device_IP ]
//	        logInfo("Soundtouch: Member of gSoundtouch_MultiroomMaster changed", "Masterchange detected!triggeringItem triggered a Masterchange:" +triggeringItem.name + "TriggeringState: " + triggeringItem.state + " Update Global vars to Master of:" + triggeringItem.name)
		postUpdate(Soundtouch_Multiroom_Master, devicename_MultiroomMaster_item.state)

                postUpdate(Soundtouch_Multiroom_Master_IP, master_device_IP_item.state)
//                logInfo("Soundtouch: Member of gSoundtouch_MultiroomMaster changed", "Update Multiroom to ON for: " + triggeringItem.name + " Update AvailableForMultiroom OFF for: " + triggeringItem.name)
                postUpdate(devicename_Multiroom_item,ON)
		postUpdate(devicename_AvailableForMultiroom_item,OFF)
	}
end

rule "Multiroom - Partymode"
when
	Item Soundtouch_Multiroom changed
then
	if (Soundtouch_Multiroom.state==ON){
		val Number MACPlaying = gSoundtouch_MacPlaying.members.filter[ NumberItem i | i.state!="" ].size
	        val Number MastersCount = gSoundtouch_Master.members.filter[ NumberItem i | i.state==ON ].size
//		logInfo("Playing and Masters:", "CurrentPlaying: " +MACPlaying + "Masterscount: " + MastersCount)		
		if (MastersCount==1){
			gSoundtouch_Multiroom.members.filter[ i | i.state != ON].forEach[ i | i.sendCommand(ON) ]
		}
	}
	else{
		postUpdate(Soundtouch_Multiroom_Master, "")
	}
end