/*************************************************
* Musikstatus je Raum
* mit State-Erstellung + Provider-Erkennung
*************************************************/

const rooms = [
   {
       name: "Wohnzimmer",
       target: "0_userdata.0.Status_Musikboxen.Wohnzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio",2:"Fernseher"} }
   },
   {
       name: "Esszimmer",
       target: "0_userdata.0.Status_Musikboxen.Esszimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   },
   {
       name: "Küche",
       target: "0_userdata.0.Status_Musikboxen.Küche_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   },
   {
       name: "Garten",
       target: "0_userdata.0.Status_Musikboxen.Garten_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 2000,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Schlafzimmer",
       target: "0_userdata.0.Status_Musikboxen.Schlafzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 2000,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Spielzimmer",
       target: "0_userdata.0.Status_Musikboxen.Spielzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 0,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Kinderzimmer",
       target: "0_userdata.0.Status_Musikboxen.Kinderzimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 2000,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Gäste WC",
       target: "0_userdata.0.Status_Musikboxen.Gaeste_WC",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       delayMs: 0,
       config: { alexaDirectProvider: true }
   },
   {
       name: "Badezimmer",
       target: "0_userdata.0.Status_Musikboxen.Badezimmer_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   },
   {
       name: "Hobbyraum",
       target: "0_userdata.0.Status_Musikboxen.Hobbyraum_Status",
       alexaState: "Deine Alexa.Player.currentState",
       alexaProvider: "Deine Alexa.Player.providerName",
       sonosState: "sonos.0.root.192_168_178_XXX.state_simple",
       sonosType: "sonos.0.root.192_168_178_XXX.current_type",
       delayMs: 0,
       config: { alexaDirectProvider: false, sonosMap: {0:"Musik von Platte",1:"TuneIn-Liveradio"} }
   }
];

/*********************** STATES ERSTELLEN ***********************/

function createTargetState(room) {
   createState(room.target, "nichts", {
       name: `Musikstatus ${room.name}`,
       type: "string",
       role: "text",
       read: true,
       write: true
   });
}

/*********************** LOGIK ***********************/

function readVal(id, def = null) {
   if (!id) return def;
   const s = getState(id);
   return s ? s.val : def;
}

function normalizeProvider(p) {
   if (!p) return "";

   const raw = String(p).trim();
   const t = raw.toLowerCase();

   if (t.includes("amazon")) return "Amazon Music";
   if (t.includes("spotify")) return "Spotify";
   if (t.includes("tunein") || t.includes("radio")) return "TuneIn-Liveradio";
   if (t.includes("audible")) return "Audible";
   if (t.includes("apple")) return "Apple Music";
   if (t.includes("deezer")) return "Deezer";
   if (t.includes("youtube")) return "YouTube";
   if (t.includes("podcast")) return "Podcast";
   if (t.includes("bluetooth") || t.includes("aux") || t.includes("line")) return "Externe Quelle";

   return raw;
}

function writeStatus(room, val) {
   if (room.delayMs > 0) {
       setStateDelayed(room.target, val, true, room.delayMs, true);
   } else {
       setState(room.target, val, true);
   }
}

function evalRoom(room) {
   const alexaPlaying = readVal(room.alexaState, false) === true;
   const alexaProvider = normalizeProvider(readVal(room.alexaProvider, ""));
   const sonosPlaying = readVal(room.sonosState, false) === true;
   const sonosType = readVal(room.sonosType, null);

   if (room.config.alexaDirectProvider) {
       if (alexaPlaying) {
           writeStatus(room, alexaProvider || "Andere Quelle");
           log(`+++ ${room.name}: ${alexaProvider || "Andere Quelle"} +++`, "debug");
       } else {
           writeStatus(room, "nichts");
       }
       return;
   }

   if (alexaPlaying && alexaProvider) {
       writeStatus(room, alexaProvider);
       return;
   }

   if (
       sonosPlaying &&
       room.config.sonosMap &&
       room.config.sonosMap[sonosType] !== undefined
   ) {
       writeStatus(room, room.config.sonosMap[sonosType]);
       return;
   }

   writeStatus(room, "nichts");
}

function initRoom(room) {
   createTargetState(room);

   const ids = [];

   if (room.alexaState) ids.push(room.alexaState);
   if (room.alexaProvider) ids.push(room.alexaProvider);
   if (room.sonosState) ids.push(room.sonosState);
   if (room.sonosType) ids.push(room.sonosType);

   if (ids.length === 0) {
       log(`Keine Trigger für ${room.name} konfiguriert`, "warn");
       return;
   }

   on({ id: ids, change: "ne" }, () => evalRoom(room));

   setTimeout(() => {
       evalRoom(room);
   }, 1000);
}

/*********************** START ***********************/

rooms.forEach(initRoom);

/**
 * Echo Stati / Lautstärke-Reset
 *
 * Funktionen:
 * - Reagiert auf Statusänderung eines Raums
 * - Prüft auf Zielstatus "nichts"
 * - Setzt Lautstärke definierter Geräte nach optionaler Verzögerung
 * - Verhindert Mehrfach-Timer pro Raum
 * - Optionales Debug-Logging
 * - Alexa notificationVolume wird explizit über notificationId gesetzt
 * - Sonderfall Kinderzimmer: nur notificationVolume, kein Player.volume
 */

const CONFIG = {
    targetStatus: 'nichts',
    defaultDelayMs: 5000,
    debug: true,
    logPrefix: '[Musikboxen]',
    minNotificationVolume: 0,
    maxNotificationVolume: 100,
    defaultNotificationOffset: 5
};

const rooms = [
    {
        name: 'Küche',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Küche_Status',
        delayMs: 0,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.661b5e9aa0b24161a4ec52b340173846.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.661b5e9aa0b24161a4ec52b340173846.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.4879f7942cdb42d596f4e24aac81e908.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.661b5e9aa0b24161a4ec52b340173846.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_18.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Wohnzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Wohnzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.025b455db7bb4720ad941b7139bcc805.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.d5794400dafd4c2cb0c8889fc15f0653.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.d5794400dafd4c2cb0c8889fc15f0653.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.d5794400dafd4c2cb0c8889fc15f0653.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_21.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Esszimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Esszimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.084e4de76a484be18aeda245e8f3f4d4.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.c31ec0fc26584e078ca0555aecfc9188.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.c31ec0fc26584e078ca0555aecfc9188.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.c31ec0fc26584e078ca0555aecfc9188.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_20.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Schlafzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Schlafzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G091MK0614730BNS.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G091MK0614730BNS.Preferences.notificationVolume',
                volume: 18,
                notificationOffset: 12
            }
        ]
    },
    {
        name: 'Hobbyraum',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Hobbyraum_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.d3127dcdc8bc4158807fcab2fcfe7fba.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.c9d487971e914e939baad79585dd7b2e.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            }
        ]
    },
    {
        name: 'Gäste WC',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Gaeste_WC',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'ne',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G090LF10718513KQ.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G090LF10718513KQ.Preferences.notificationVolume',
                volume: 15,
                notificationOffset: 8
            }
        ]
    },
    {
        name: 'Badezimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Badezimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.828b54738e2a44a29d9331868a046c38.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.eba89b7180384792a24f92847baea082.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'alexa2.0.Echo-Devices.eba89b7180384792a24f92847baea082.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.eba89b7180384792a24f92847baea082.Preferences.notificationVolume',
                volume: 10,
                notificationOffset: 5
            },
            {
                id: 'sonos.0.root.192_168_178_17.volume',
                volume: 10
            }
        ]
    },
    {
        name: 'Spielzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Spielzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G2A0P3077407031K.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G2A0P3077407031K.Preferences.notificationVolume',
                volume: 25,
                notificationOffset: 15
            }
        ]
    },
    {
        name: 'Kinderzimmer',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Kinderzimmer_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                notificationId: 'alexa2.0.Echo-Devices.G0911B05926204Q7.Preferences.notificationVolume',
                volume: 11,
                notificationOffset: 6,
                notificationOnly: true
            }
        ]
    },
    {
        name: 'Garten',
        enabled: true,
        statusId: '0_userdata.0.Status_Musikboxen.Garten_Status',
        delayMs: CONFIG.defaultDelayMs,
        trigger: 'any',
        devices: [
            {
                id: 'alexa2.0.Echo-Devices.G091AA08052203UL.Player.volume',
                notificationId: 'alexa2.0.Echo-Devices.G091AA08052203UL.Preferences.notificationVolume',
                volume: 15,
                notificationOffset: 8
            }
        ]
    }
];

const activeTimers = {};

function logInfo(msg) {
    log(`${CONFIG.logPrefix} ${msg}`, 'info');
}

function logDebug(msg) {
    if (CONFIG.debug) {
        log(`${CONFIG.logPrefix} ${msg}`, 'debug');
    }
}

function logWarn(msg) {
    log(`${CONFIG.logPrefix} ${msg}`, 'warn');
}

function logError(msg) {
    log(`${CONFIG.logPrefix} ${msg}`, 'error');
}

function isTargetStatus(value) {
    if (value === null || value === undefined) return false;
    return String(value).trim() === CONFIG.targetStatus;
}

function isValidVolume(volume) {
    return typeof volume === 'number' && isFinite(volume) && volume >= 0 && volume <= 100;
}

function stateExists(id) {
    try {
        return !!getObject(id);
    } catch (e) {
        return false;
    }
}

function clamp(value, min, max) {
    return Math.max(min, Math.min(max, value));
}

function getNotificationVolume(volume, notificationOffset) {
    const offset = typeof notificationOffset === 'number'
        ? notificationOffset
        : CONFIG.defaultNotificationOffset;

    return clamp(
        volume - offset,
        CONFIG.minNotificationVolume,
        CONFIG.maxNotificationVolume
    );
}

function clearRoomTimer(roomName) {
    if (activeTimers[roomName]) {
        clearTimeout(activeTimers[roomName]);
        activeTimers[roomName] = null;
        logDebug(`${roomName}: vorhandener Timer gelöscht`);
    }
}

function setDeviceVolume(device, roomName) {
    if (!device) {
        logWarn(`${roomName}: ungültiges Gerät übersprungen`);
        return;
    }

    if (!isValidVolume(device.volume)) {
        logWarn(`${roomName}: ungültige Lautstärke ${device.volume}`);
        return;
    }

    if (!device.notificationOnly) {
        if (!device.id) {
            logWarn(`${roomName}: Gerät ohne ID übersprungen`);
            return;
        }

        if (!stateExists(device.id)) {
            logWarn(`${roomName}: Datenpunkt nicht gefunden: ${device.id}`);
            return;
        }

        try {
            setState(device.id, device.volume);
            logInfo(`${roomName}: Volume ${device.volume} gesetzt -> ${device.id}`);
        } catch (e) {
            logError(`${roomName}: Fehler beim Setzen von ${device.id}: ${e}`);
            return;
        }
    }

    if (device.notificationId) {
        if (!stateExists(device.notificationId)) {
            logWarn(`${roomName}: notificationVolume-Datenpunkt nicht gefunden: ${device.notificationId}`);
            return;
        }

        const notificationVolume = getNotificationVolume(device.volume, device.notificationOffset);

        try {
            setState(device.notificationId, notificationVolume);
            logInfo(`${roomName}: notificationVolume ${notificationVolume} gesetzt -> ${device.notificationId}`);
        } catch (e) {
            logError(`${roomName}: Fehler beim Setzen von ${device.notificationId}: ${e}`);
        }
    }
}

function resetRoomVolume(room) {
    if (!room || !Array.isArray(room.devices) || room.devices.length === 0) {
        logWarn(`${room && room.name ? room.name : 'Unbekannter Raum'}: keine Geräte konfiguriert`);
        activeTimers[room && room.name ? room.name : 'unknown'] = null;
        return;
    }

    room.devices.forEach(device => setDeviceVolume(device, room.name));
    activeTimers[room.name] = null;
}

function scheduleReset(room) {
    clearRoomTimer(room.name);

    const delayMs = typeof room.delayMs === 'number' && room.delayMs >= 0
        ? room.delayMs
        : CONFIG.defaultDelayMs;

    if (delayMs === 0) {
        logDebug(`${room.name}: sofortiger Reset`);
        resetRoomVolume(room);
        return;
    }

    logDebug(`${room.name}: Reset in ${delayMs} ms geplant`);

    activeTimers[room.name] = setTimeout(() => {
        activeTimers[room.name] = null;
        resetRoomVolume(room);
    }, delayMs);
}

function registerRoom(room) {
    if (!room || !room.name || !room.statusId) {
        logWarn('Ungültige Raum-Konfiguration übersprungen');
        return;
    }

    if (!room.enabled) {
        logDebug(`${room.name}: deaktiviert`);
        return;
    }

    if (!stateExists(room.statusId)) {
        logWarn(`${room.name}: Status-Datenpunkt nicht gefunden: ${room.statusId}`);
        return;
    }

    const trigger = room.trigger || 'ne';

    on({ id: room.statusId, change: trigger }, obj => {
        try {
            if (!obj || !obj.state) {
                logDebug(`${room.name}: Event ohne state erhalten`);
                return;
            }

            const newValue = obj.state.val;
            const oldValue = obj.oldState ? obj.oldState.val : undefined;
            const ack = obj.state.ack;

            logDebug(`${room.name}: Event | alt="${oldValue}" neu="${newValue}" ack=${ack}`);

            if (!isTargetStatus(newValue)) {
                logDebug(`${room.name}: Status ist nicht "${CONFIG.targetStatus}", kein Reset`);
                return;
            }

            scheduleReset(room);
        } catch (e) {
            logError(`${room.name}: Fehler im Event-Handler: ${e}`);
        }
    });

    logInfo(`${room.name}: Trigger registriert (${trigger}) auf ${room.statusId}`);
}

rooms.forEach(registerRoom);
logInfo('Lautstärke-Reset-Skript mit expliziten notificationIds gestartet');