using Toybox.Application;
using Toybox.Graphics;
using Toybox.System;
using Toybox.Time;
using Toybox.Time.Gregorian;
using Toybox.WatchUi;
using Toybox.BluetoothLowEnergy as Ble;


class BleDiscoverResult
{
    private var moment;
    private var data;
    private var name;
    private var uuid;

    function initialize(moment, scanResult) {
        update(moment, scanResult);
    }

    function update(moment, scanResult) {
        self.moment = moment;
        data = scanResult;

        if (name == null) {
            name = _getDeviceName(scanResult);
        }

        uuid = _getServiceUuids(scanResult);
    }

    function isSameDevice(scanResult) {
        return scanResult.isSameDevice(data);
    }

    function getTimeStamp() {
        var info = Gregorian.info(self.moment, Time.FORMAT_SHORT);

        // convert from 24 to 12-hour clock
        info.hour = 1 + (info.hour + 11) % 12;

        // display H:MM:SS
        info.hour = info.hour.format("%d");
        info.min = info.min.format("%02d");
        info.sec = info.sec.format("%02d");

        return Lang.format("$1$:$2$:$3$", [ info.hour, info.min, info.sec ] );
    }

    function getDescription() {
        if (name != null) {
            return Lang.format("name=$1$", [ name ]);
        }

        if (uuid != null) {
            return Lang.format("uuid=$1$", [ uuid ]);
        }

        return Lang.format("rssi=$1$", [ data.getRssi() ]);
    }

    private function _getDeviceName(scanResult) {
        return scanResult.getDeviceName();
    }

    private function _getServiceUuids(scanResult) {
        var iter = scanResult.getServiceUuids();
        if (iter != null) {
            var uuids = [];

            var uuid = iter.next();
            while (uuid != null) {
                uuids.add(uuid.toString());
                uuid = iter.next();
            }

            if (uuids.size() != 0) {
                return uuids;
            }
        }

        return null;
    }
}


class BleDiscoverModel extends Ble.BleDelegate
{
    hidden var _scanResults;
    hidden var _scanState;
    hidden var _maxResults;

    function initialize() {
        BleDelegate.initialize();

        _scanResults = [];
        _scanState = Ble.SCAN_STATE_OFF;

        _maxResults = 10;
    }

    function onStart() {
    }

    function onStop() {
    }

    private function addScanResult(moment, scanResult) {

        // if we already have a result for the same device, just update it
        for (var i = 0; i < _scanResults.size(); ++i) {
            var foundResult = _scanResults[i];
            if (foundResult.isSameDevice(scanResult)) {
                foundResult.update(moment, scanResult);
                return;
            }
        }

        // otherwise append the result, making sure we don't have more than we can
        // display

        _scanResults = _scanResults.slice(-_maxResults, null);
        _scanResults.add(new BleDiscoverResult(moment, scanResult));
    }


    function onScanResults(scanResults) {
        var moment = Time.now();

        // add/update result
        var scanResult = scanResults.next();
        while (scanResult != null) {
            addScanResult(moment, scanResult);
            scanResult = scanResults.next();
        }

        WatchUi.requestUpdate();
    }

    function getScanResults() {
        return _scanResults;
    }

    function clearScanResults() {
        _scanResults = [];
        WatchUi.requestUpdate();
    }

    function onScanStateChange(scanState, status) {
        _scanState = scanState;
        WatchUi.requestUpdate();
    }

    function isScanning() {
        return _scanState != Ble.SCAN_STATE_OFF;
    }
}


class BleDiscoverView extends WatchUi.View
{
    hidden var _xpos;
    hidden var _font;
    hidden var _ljust;
    hidden var _rjust;
    hidden var _cjust;
    hidden var _lineHeight;
    hidden var _viewHeight;
    hidden var _model;

    function initialize(model) {
        View.initialize();
        _model = model;
    }

    function onLayout(dc) {
        _xpos = dc.getWidth() / 3;

        _font = Graphics.FONT_XTINY;
        _ljust = Graphics.TEXT_JUSTIFY_LEFT;
        _rjust = Graphics.TEXT_JUSTIFY_RIGHT;
        _cjust = Graphics.TEXT_JUSTIFY_CENTER;

        _lineHeight = dc.getFontHeight(_font);
        _viewHeight = dc.getHeight();
    }

    function onUpdate(dc) {
        dc.setColor(Graphics.COLOR_WHITE, Graphics.COLOR_BLACK);
        dc.clear();

        var ypos = _lineHeight;

        var isScanning = _model.isScanning();

        var scanResults = _model.getScanResults();
        if (scanResults.size() == 0) {
            var ypos = dc.getHeight() / 2 - (3 * _lineHeight) / 2;

            dc.drawText(dc.getWidth() / 2, ypos, _font, "MENU to clear results", _cjust);
            ypos += _lineHeight;
            dc.drawText(dc.getWidth() / 2, ypos, _font, Lang.format("SELECT to $1$ scanning", [ isScanning ? "STOP" : "START" ]), _cjust);
            ypos += _lineHeight;
            dc.drawText(dc.getWidth() / 2, ypos, _font, "BACK to exit", _cjust);
        }
        else {
            for (var i = 0; i < scanResults.size(); ++i) {
                var scanResult = scanResults[i];

                var timestamp = scanResult.getTimeStamp();
                dc.drawText(_xpos, ypos, _font, Lang.format("$1$: ", [ timestamp ]), _rjust);

                // either `name`, [ uuid, ... ], or null
                var description = scanResult.getDescription();
                dc.drawText(_xpos, ypos, _font, Lang.format("$1$", [ description ]), _ljust);
                ypos += _lineHeight;
            }
        }

        var color;
        if (isScanning) {
            color = Graphics.COLOR_GREEN;
        }
        else {
            color = Graphics.COLOR_RED;
        }

        dc.setColor(color, color);
        dc.fillCircle(dc.getWidth() - 20, dc.getHeight() / 2, 10);
    }
}


class BleDiscoverController extends WatchUi.BehaviorDelegate
{
    hidden var _view;
    hidden var _model;

    function initialize(model) {
        BehaviorDelegate.initialize();
        _model = model;
    }

    function onStart() {
        Ble.setDelegate(_model);
    }

    function onStop() {
        // Ble.setDelegate(null);
    }

    function onSelect() {
        var isScanning = _model.isScanning();
        if (isScanning) {
            Ble.setScanState(Ble.SCAN_STATE_OFF);
        } else {
            Ble.setScanState(Ble.SCAN_STATE_SCANNING);
        }

        return true;
    }

    function onMenu() {
        _model.clearScanResults();
        WatchUi.requestUpdate();
    }

    function getInitialView() {
        _view = new BleDiscoverView(_model);
        return [ _view, self ];
    }
}


class BleDiscoverApp extends Application.AppBase {

    hidden var _controller;
    hidden var _model;

    function initialize() {
        AppBase.initialize();
    }

    function onStart(state) {
        _model = new BleDiscoverModel();
        _model.onStart();

        _controller = new BleDiscoverController(_model);
        _controller.onStart();
    }

    function onStop(state) {
        _controller.onStop();
        _controller = null;

        _model.onStop();
        _model = null;
    }

    function getInitialView() {
        return _controller.getInitialView();
    }
}