import { IAccessory } from "./models/iAccessory";
import Api = require("node-hue-api/lib/api/Api");
import Light = require("node-hue-api/lib/model/Light");
import LightState = require("node-hue-api/lib/model/lightstate/LightState");
import { Sleep } from "./sleep";
import { IConfig } from "./models/iConfig";
//@ts-ignore
import { GetTimesResult, getTimes } from "suncalc";
import HueError = require("node-hue-api/lib/HueError");
import cron from "node-cron";
import { WizBulb } from "@watsonb8/wiz-lib/build/wizBulb";
import { colorTemperature2rgb, Pilot, RGB } from "@watsonb8/wiz-lib";

let Service: HAPNodeJS.Service;
let Characteristic: HAPNodeJS.Characteristic;
const SECONDS_IN_DAY = 86400000;
const MINUTES_IN_MILLISECOND = 60000;
const SECONDS_IN_HOUR = 3600;

export interface IFluxProps {
    api: any;
    log: any;
    homebridge: any;
    hue: Api;
    wizBulbs: Array<WizBulb>;
    config: IConfig;
}

export class FluxAccessory implements IAccessory {
    private _api: any;
    private _homebridge: any;
    private _log: any = {};
    private _config: IConfig;
    private _isActive: boolean;

    //Service fields
    private _switchService: HAPNodeJS.Service;
    private _infoService: HAPNodeJS.Service;

    private _hue: Api;

    private _lights: Array<Light> = [];
    private _wizLights: Array<WizBulb> = [];

    private _times: GetTimesResult;

    constructor(props: IFluxProps) {
        //Assign class variables
        this._log = props.log;
        this._api = props.api;
        this._config = props.config;
        Service = props.api.hap.Service;
        Characteristic = props.api.hap.Characteristic;
        this._homebridge = props.homebridge;
        this._isActive = false;
        this._wizLights = props.wizBulbs;

        this._times = getTimes(
            new Date(),
            this._config.latitude,
            this._config.longitude
        );

        //Schedule job to refresh times
        cron.schedule(
            "0 12 * * *",
            () => {
                this._times = getTimes(
                    new Date(),
                    this._config.latitude,
                    this._config.longitude
                );
                this._log("Updated sunset times");
            },
            {
                scheduled: true,
            }
        ).start();

        this._hue = props.hue;
        this.name = this._config.name;

        this.platformAccessory = new this._homebridge.platformAccessory(
            this.name,
            this.generateUUID(),
            this._homebridge.hap.Accessory.Categories.SWITCH
        );

        //@ts-ignore
        this._infoService = new Service.AccessoryInformation();
        this._infoService.setCharacteristic(
            Characteristic.Manufacturer,
            "Brandon Watson"
        );
        this._infoService.setCharacteristic(Characteristic.Model, "F.lux");
        this._infoService.setCharacteristic(
            Characteristic.SerialNumber,
            "123-456-789"
        );

        this._switchService = new Service.Switch(this.name, "fluxService");

        this._switchService
            .getCharacteristic(Characteristic.On)
            //@ts-ignore
            .on("set", this.onSetEnabled)
            //@ts-ignore
            .on("get", this.onGetEnabled);
    }

    public name: string = "Flux";

    public platformAccessory: any;

    /**
     * Handler for switch set event
     * @param callback The callback function to call when complete
     */
    private onSetEnabled = async (
        activeState: boolean,
        callback: (error?: Error | null | undefined) => void
    ) => {
        if (activeState) {
            this._times = getTimes(
                new Date(),
                this._config.latitude,
                this._config.longitude
            );
            this.update();
        } else {
            this._isActive = false;
        }
        return callback();
    };

    /**
     * Handler for switch get event
     * @param callback The callback function to call when complete
     */
    private onGetEnabled(
        callback: (error: Error | null, value: boolean) => void
    ): void {
        callback(null, this._isActive);
        // return this._isActive;
    }

    /**
     * Called by homebridge to gather services.
     */
    public getServices = (): Array<HAPNodeJS.Service> => {
        return [this._infoService, this._switchService!];
    };

    /**
     * Popuplates internal lights array using the configuration values
     */
    private getLights = async (): Promise<void> => {
        for (const value of this._config.lights) {
            //@ts-ignore
            const light: Light = await this._hue.lights.getLightByName(value);
            this._lights.push(light);
        }
    };

    private colorTempToRgb = (kelvin: number): RGB => {
        var temp = kelvin / 100;
        var red, green, blue;
        if (temp <= 66) {
            red = 255;
            green = temp;
            green = 99.4708025861 * Math.log(green) - 161.1195681661;

            if (temp <= 19) {
                blue = 0;
            } else {
                blue = temp - 10;
                blue = 138.5177312231 * Math.log(blue) - 305.0447927307;
            }
        } else {
            red = temp - 60;
            red = 329.698727446 * Math.pow(red, -0.1332047592);

            green = temp - 60;
            green = 288.1221695283 * Math.pow(green, -0.0755148492);

            blue = 255;
        }
        return {
            r: this.clamp(red, 0, 255),
            g: this.clamp(green, 0, 255),
            b: this.clamp(blue, 0, 255),
        };
    };

    private clamp(x: number, min: number, max: number) {
        if (x < min) {
            return min;
        }
        if (x > max) {
            return max;
        }
        return x;
    }

    private isHueError = (object: any): object is HueError => {
        return "_hueError" in object;
    };

    private setHueLights = async (state: LightState) => {
        const promises: Array<Promise<unknown> | PromiseLike<unknown>> = [];
        this._lights.map(async (light: Light) => {
            try {
                await this._hue.lights.setLightState(light.id, state);
            } catch (err) {
                if (
                    this.isHueError(err) &&
                    err.message ===
                        "parameter, xy, is not modifiable. Device is set to off."
                ) {
                    //Eat this
                } else {
                    this._log(`Error while setting lights: ${err}`);
                }
            }
        });

        await Promise.all(promises);
    };

    private setWizLights = async (rgb: RGB, fade: number): Promise<void> => {
        await Promise.all(
            this._wizLights.map(async (bulb) => {
                const pilot = await bulb.get();
                bulb.set(rgb, pilot?.dimming, fade);
            })
        );
        return;
    };

    /**
     * Helper function to generate a UUID
     */
    private generateUUID(): string {
        // Public Domain/MIT
        var d = new Date().getTime();
        if (
            typeof performance !== "undefined" &&
            typeof performance.now === "function"
        ) {
            d += performance.now(); //use high-precision timer if available
        }
        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
            /[xy]/g,
            function (c) {
                var r = (d + Math.random() * 16) % 16 | 0;
                d = Math.floor(d / 16);
                return (c === "x" ? r : (r & 0x3) | 0x8).toString(16);
            }
        );
    }

    /**
     * Gets adjusted color temperature.
     */
    private getTempOffset = (
        startTemp: number,
        endTemp: number,
        startTime: Date,
        endTime: Date
    ) => {
        const now = this.getNow().getTime();
        const percentComplete =
            (now - startTime.getTime()) /
            (endTime.getTime() - startTime.getTime());
        const tempRange = Math.abs(startTemp - endTemp);
        const tempOffset = tempRange * percentComplete;
        return startTemp - tempOffset;
    };

    /**
     * Get the current time. Use test time if present.
     */
    private getNow() {
        if (this._config.testNowDateString) {
            return new Date(this._config.testNowDateString);
        } else {
            return new Date();
        }
    }

    private update = async (): Promise<void> => {
        this._isActive = true;
        while (this._isActive) {
            if (this._lights.length === 0) {
                await this.getLights();
            }

            const now = this.getNow();
            //Pad start time by an hour before sunset
            const start = new Date(
                this._times.sunset.getTime() - 60 * MINUTES_IN_MILLISECOND
            );
            const sunsetStart = this._times.sunsetStart;
            const sunsetEnd = new Date(
                this._times.sunset.getTime() + this._config.sunsetDuration
            );
            const nightStart = new Date(
                sunsetEnd.getTime() + 60 * MINUTES_IN_MILLISECOND
            );
            const sunrise = new Date(
                this._times.sunrise.getTime() + 1 * SECONDS_IN_DAY
            );

            const startColorTemp = this._config.ceilingColorTemp
                ? this._config.ceilingColorTemp
                : 4000;
            const sunsetColorTemp = this._config.sunsetColorTemp
                ? this._config.sunsetColorTemp
                : 2800;
            const floorColorTemp = this._config.floorColorTemp
                ? this._config.floorColorTemp
                : 1900;

            let newTemp = 0;

            if (start < now && now < sunsetStart) {
                newTemp = this.getTempOffset(
                    startColorTemp,
                    sunsetColorTemp,
                    start,
                    sunsetStart
                );
            } else if (sunsetStart < now && now < sunsetEnd) {
                newTemp = this._config.sunsetColorTemp;
            } else if (sunsetEnd < now && now < nightStart) {
                newTemp = this.getTempOffset(
                    sunsetColorTemp,
                    floorColorTemp,
                    sunsetEnd,
                    nightStart
                );
            } else if (nightStart < now && now < sunrise) {
                newTemp = this._config.floorColorTemp;
            }

            //Set lights
            const hueRGB = this.colorTempToRgb(newTemp);
            const wizRGB = colorTemperature2rgb(newTemp);
            if (hueRGB && newTemp !== 0) {
                const lightState = new LightState();
                lightState
                    .transitionInMillis(
                        this._config.transition ? this._config.transition : 5000
                    )
                    .rgb(hueRGB.r ?? 0, hueRGB.g ?? 0, hueRGB.b ?? 0);
                await this.setHueLights(lightState);
                await this.setWizLights(
                    wizRGB,
                    this._config.transition ? this._config.transition / 1000 : 5
                );
                this._log(
                    `Adjusting light temp to ${newTemp}, ${JSON.stringify(
                        hueRGB
                    )}`
                );
            }

            await Sleep(this._config.delay ? this._config.delay : 60000);
        }
    };
}