#pragma once

#define MAIN_DEVICE_ID "rc-gateway"

#include "ha.h"

using namespace Ha;

typedef unordered_multimap<unsigned long, Ha::Switch*> mapswitches;

mapswitches onSwitches;
mapswitches offSwitches;
unordered_map<string, Ha::Switch*> p1Switches;

auto gatewayDevice = &DeviceConfig::create(MAIN_DEVICE_ID).withName("RC Gateway").withManufacturer("Adafruit").withModel("Huzzah Esp8266");

namespace OilTank {
    Sensor* buildRoomSensor(const char* id) {
        DeviceConfig* device = &DeviceConfig::create(id)
            .withName("Servers room")
            .withManufacturer("Atmel")
            .withModel("AtTiny85")
            .withArea("Basement")
            .withParent(gatewayDevice);
        return Builder<TemperatureSensor>::instance(id)
            .asDevice(device)
            .withValueTemplate("{{ value_json.sensor.temperature }}")
            .addDiagnostic(new VoltageSensor{id, "Battery voltage", "{{ value_json.sensor.diagnostic.voltage }}"})
            .addDiagnostic(new BatterySensor{id, "Battery level", "{{ ((states('sensor.servers_room_battery_voltage')|float-2.5)|round(2)*100/2)|int }}"})
            .build();
    }

    Sensor* buildTankSensor(const char* id) {
        DeviceConfig* device = &DeviceConfig::create(id)
            .withName("Oil tank")
            .withManufacturer("Arduino")
            .withModel("Pro Mini")
            .withArea("Basement")
            .withParent(gatewayDevice);
        return Builder<Sensor>::instance(new Sensor{ "Depth", id })
            .asDevice(device)
            .withDeviceClass("distance")
            .withUnitMseasure("cm")
            .withValueTemplate("{{ value_json.sensor.value }}")
            .addSecondary(
                Builder<Sensor>::instance(new Sensor{ "Level", id })
                .withUnitMseasure("%")
                .withValueTemplate("{{ 100 - ((value_json.sensor.value-12)|float*100/120)|round(2) }}")
                .build()
            )
            .addDiagnostic(new VoltageSensor{id, "Battery voltage", "{{ value_json.sensor.diagnostic.voltage }}"})
            .addDiagnostic(new BatterySensor{id, "Battery level", "{{ ((states('sensor.oil_tank_battery_voltage')|float-4.8)|round(2)*100/1.6)|int }}"})
            .build();
    }
}

struct PollinSwitch : Switch {
    const char* group;
    unsigned char channel;

    PollinSwitch(const char* name, const char* group, const unsigned char channel, const char* area = nullptr)
        : Switch(nullptr, [group, channel]{
                // copy id from string into a new pointer, to avoid memory leaks
                string s = Protocol_1::buildId(group, channel);
                char* uId = new char[s.length() + 1];
                strcpy(uId, s.c_str());
                return uId;
            }()), group(group), channel(channel) {
        mainDevice = &DeviceConfig::create(id).withName(name).withManufacturer("Pollin").withArea(area).withParent(gatewayDevice);
        withStateTopic();
        deviceClass = "outlet";
        p1Switches.insert({ string(id), this });
    }

    void onCommand(const char* msg) override {
        strcmp("ON", msg) == 0 ? mySwitch.switchOn(group, channel) : mySwitch.switchOff(group, channel);
        publisher(stateTopic, msg);
    }

};

struct EasyHomeSwitch : Switch {
    unsigned long on[8] = { 4326554, 4537114, 4767530, 4972714 };
    unsigned long off[8] = { 4483146, 4626810, 4661562, 4819642 };

    EasyHomeSwitch(const char* name, const char* id, unsigned long on[4], unsigned long off[4], const char* area = nullptr)
        : Switch(nullptr, id) {
        memcpy(&this->on[4], on, 4 * sizeof(unsigned long));
        memcpy(&this->off[4], off, 4 * sizeof(unsigned long));
        mainDevice = &DeviceConfig::create(id).withName(name).withManufacturer("Intertek").withModel("Easy Home").withArea(area).withParent(gatewayDevice);
        withStateTopic();
        deviceClass = "outlet";
        for (int i = 0; i < 8; i++) {
            onSwitches.insert({ this->on[i], this });
            offSwitches.insert({ this->off[i], this });
        }
    }

    void onCommand(const char* msg) override {
        mySwitch.setProtocol(4);
        strcmp("ON", msg) == 0 ? mySwitch.send(on[4], 24) : mySwitch.send(off[4], 24);
        publisher(stateTopic, msg);
    }
};

Command* commands[] = {
    Builder<Button>::instance(new Button{"Restart", "restart",
        [](const char* msg) {
            if (strcmp("PRESS", msg) == 0) ESP.restart();
        }
    }).asDevice(gatewayDevice).build(),
    Builder<Button>::instance(new Button{"Front door", "doorbell_front",
        [](const char* msg) {
            if (strcmp("PRESS", msg) == 0) doorbell.ring("00000000110100101000100");
        }
    })
    .asDevice(
        &DeviceConfig::create("doorbell")
        .withName("Doorbell")
        .withManufacturer("Thomson")
        .withModel("Kinetic Halo")
        .withParent(gatewayDevice)
        )
    .build(),
    new EasyHomeSwitch{"FritzBox", "easy_home_a", (unsigned long[4]) { 4483136, 4626800, 4661552, 4819632 }, (unsigned long[4]) { 4326544, 4537104, 4767520, 4972704 }, "Basement"},
    new EasyHomeSwitch{"Outside", "easy_home_b", (unsigned long[4]) { 4483140, 4626804, 4661556, 4819636 }, (unsigned long[4]) { 4326548, 4537108, 4767524, 4972708 }, "Basement"},
    new PollinSwitch{"Meeting sensor", "00001", 1, "Dining room"},
    new PollinSwitch{"Fire Tv", "00001", 2, "Living room"},
    new PollinSwitch{"Diningroom player", "00001", 3, "Dining room"},
    new PollinSwitch{"Train", "11111", 4, "Playroom"}
};

Sensor* sensors[] = {
    OilTank::buildRoomSensor("4"),
    OilTank::buildTankSensor("7")
};