#!/usr/bin/env python3
# vim: ts=2 sw=2 et

import grp
import json
import os
import signal
import stat
import subprocess
import sys
import time
from configparser import ConfigParser

import pifacedigitalio

# Definitions for output
LED_RED = 6
LED_GREEN = 7
RELAYS_LOCK = 0
RELAYS_UNLOCK = 1

# Definitions for input
DOOR_BELL = 0
REED_RELAYS = 1  # not implemented yet

# Definitions for LED color
RED = 1
GREEN = 2
ORANGE = 3

# Read config
parser = ConfigParser()
parser.read('/etc/foodoord.conf')

DOORAPI = parser.get('doorstatus', 'status_url')
CONSUMERKEY = parser.get('doorstatus', 'key')
CONSUMERSECRET = parser.get('doorstatus', 'secret')


def update_api(locked):
    try:
        subprocess.check_call([
            "/usr/bin/curl", "-XPOST",
            "--header", "Content-Type: application/json",
            "--data",
            json.dumps({"consumer_key": CONSUMERKEY, "consumer_secret": CONSUMERSECRET, "aerie": locked})
        ])
    except:
        pass


def set_led(color):
    if color == RED:
        pifacedigital.leds[LED_RED].turn_on()
        pifacedigital.leds[LED_GREEN].turn_off()
    elif color == GREEN:
        pifacedigital.leds[LED_GREEN].turn_on()
        pifacedigital.leds[LED_RED].turn_off()
    elif color == ORANGE:
        pifacedigital.leds[LED_RED].turn_on()
        pifacedigital.leds[LED_GREEN].turn_on()


class Foodoord:
    def __init__(self):
        self.status_open = False

        self.listener = pifacedigitalio.InputEventListener()
        self.listener.register(0, pifacedigitalio.IODIR_RISING_EDGE, self.doorbell, settle_time=10)
        self.listener.register(1, pifacedigitalio.IODIR_RISING_EDGE, self.close_button, settle_time=5)

    def signal_handler(self, _signal, _frame):
        self.listener.deactivate()
        os.remove("/var/run/foodoord.pipe")

        update_api(True)
        set_led(RED)
        sys.exit(0)

    def doorbell(self, event):
        if self.status_open:
            pifacedigital.relays[RELAYS_UNLOCK].toggle()
            time.sleep(2)
            pifacedigital.relays[RELAYS_UNLOCK].toggle()

    def close_button(self, _event):
        self.status_open = False
        update_api(True)
        set_led(RED)

    def main(self):
        self.listener.activate()

        pifacedigital = pifacedigitalio.PiFaceDigital()
        signal.signal(signal.SIGTERM, self.signal_handler)

        # Start settings
        pifacedigital.leds[LED_RED].turn_on()

        # Setting up FiFo to get sshd-output
        try:
            os.mkfifo("/var/run/foodoord.pipe")
            os.chown("/var/run/foodoord.pipe", -1, grp.getgrnam('foodoor')[2])
            os.chmod("/var/run/foodoord.pipe", stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP)
        except OSError:
            pass

        ssh_input = open("/var/run/foodoord.pipe", "r")
        while True:
            # Read sshd-output from pipe
            pipe_cmd = ssh_input.readline().strip()

            if pipe_cmd == "close" and self.status_open:
                pifacedigital.relays[RELAYS_LOCK].toggle()
                time.sleep(1)
                pifacedigital.relays[RELAYS_LOCK].toggle()

                self.status_open = False
                update_api(True)
                set_led(RED)

            elif pipe_cmd == "open":
                pifacedigital.relays[RELAYS_UNLOCK].toggle()
                time.sleep(2)
                pifacedigital.relays[RELAYS_UNLOCK].toggle()

                if not self.status_open:
                    update_api(False)
                self.status_open = True
                set_led(GREEN)

            time.sleep(0.1)


if __name__ == "__main__":
    Foodoord().main()