const hap = require("hap-nodejs");
const pysh = require("python-shell");

const Accessory = hap.Accessory;
const Characteristic = hap.Characteristic;
const CharacteristicEventTypes = hap.CharacteristicEventTypes;
const AccessoryEventTypes = hap.AccessoryEventTypes;
const Service = hap.Service;
const uuid = hap.uuid;

const accessoryUuid = hap.uuid.generate("hap.accessories.doorbell-lock");
const accessory = new Accessory("Doorbell and Lock", accessoryUuid);

const doorbellService = new Service.Doorbell("Doorbell");
const lockService = new Service.LockMechanism("Lock");

const lockTargetStateCharacteristic = lockService.getCharacteristic(Characteristic.LockTargetState);
const lockCurrentStateCharacteristic = lockService.getCharacteristic(Characteristic.LockCurrentState);

const doorbellSwitchCharacteristic = doorbellService.getCharacteristic(Characteristic.ProgrammableSwitchEvent);

function Door() {
    this.lockTimeout = 10000; // milliseconds - 10 sec

    this.pyshell = new pysh.PythonShell("doord.py", {
        mode: "text",
        pythonPath: "/usr/bin/python3",
        pythonOptions: ["-u"],
        scriptPath: "python/"
    });

    this.lock = () => {
        console.log("locking door");
        this.pyshell.send("lock");
    };

    this.unlock = () => {
        console.log("unlocking door");
        this.pyshell.send("unlock");
    };

    this.identify = () => { console.log("identify door"); };

    this.listenDoorbell = (doorbellOnCallback, doorbellOffCallback) => {
        this.pyshell.on("message", (message) => {
            console.log(message);
            switch(message) {
            case "doorbell on":
                doorbellOnCallback();
                break;
            case "doorbell off":
                doorbellOffCallback();
                break;
            }
        });
    };
}

const door = new Door();

function setDoorTargetState(value) {
    switch(value) {
    case Characteristic.LockTargetState.UNSECURED:
        unlockDoor();
        break;
    case Characteristic.LockTargetState.SECURED:
        lockDoor();
        break;
    }
}

function unlockDoor() {
    door.unlock();
    lockCurrentStateCharacteristic.setValue(Characteristic.LockCurrentState.UNSECURED);
    scheduleUnlockTimeout();
}

function lockDoor() {
    door.lock();
    lockCurrentStateCharacteristic.setValue(Characteristic.LockCurrentState.SECURED);
}

function scheduleUnlockTimeout() {
    setTimeout(() => {
        console.log("unlock timeout door");
        lockTargetStateCharacteristic.setValue(Characteristic.LockTargetState.SECURED);
    }, door.lockTimeout);
}

door.listenDoorbell(
    () => {
        doorbellSwitchCharacteristic.setValue(Characteristic.ProgrammableSwitchEvent.SINGLE_PRESS);
    },
    () => {}
);

// set initial state
lockTargetStateCharacteristic.setValue(Characteristic.LockTargetState.SECURED);
lockCurrentStateCharacteristic.setValue(Characteristic.LockCurrentState.SECURED);
lockTargetStateCharacteristic.on(CharacteristicEventTypes.SET, (value, callback) => {
    setDoorTargetState(value);
    callback();
});

accessory.on(AccessoryEventTypes.IDENTIFY, (paired, callback) => {
    door.identify();
    callback();
});

accessory.addService(doorbellService);
accessory.addService(lockService);

// pseudo-services
accessory.addService(Service.CameraRTPStreamManagement, "Pseudo-Camera");
accessory.addService(Service.Speaker, "Pseudo-Speaker");
accessory.addService(Service.Microphone, "Pseudo-Microphone");

accessory.getService(Service.AccessoryInformation)
    .setCharacteristic(Characteristic.Manufacturer, "Raspberry Pi")
    .setCharacteristic(Characteristic.Model, "Zero W")
    .setCharacteristic(Characteristic.SerialNumber, "A1S2NASF88EW");

accessory.publish({
  username: "C1:5D:3A:EA:54:AB",
  pincode: "031-45-154",
  category: hap.Categories.DOOR_LOCK
});

console.log("Accessory initialized");