package nodomain.freeyourgadget.gadgetbridge.service;

import android.content.Context;
import android.content.Intent;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.Set;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import nodomain.freeyourgadget.gadgetbridge.GBApplication;
import nodomain.freeyourgadget.gadgetbridge.devices.SleepAsAndroidFeature;
import nodomain.freeyourgadget.gadgetbridge.externalevents.sleepasandroid.SleepAsAndroidAction;
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
import nodomain.freeyourgadget.gadgetbridge.util.Prefs;

public class SleepAsAndroidSender {

    private final Logger LOG = LoggerFactory.getLogger(SleepAsAndroidSender.class);
    private final String PACKAGE_SLEEP_AS_ANDROID = "com.urbandroid.sleep";
    private final String ACTION_EXTRA_DATA_UPDATE = "com.urbandroid.sleep.ACTION_EXTRA_DATA_UPDATE";
    private final String ACTION_MOVEMENT_DATA_UPDATE = "com.urbandroid.sleep.watch.DATA_UPDATE";
    private final String ACTION_HEART_RATE_DATA_UPDATE = "com.urbandroid.sleep.watch.HR_DATA_UPDATE";
    private final String ACTION_RESUME_FROM_WATCH = "com.urbandroid.sleep.watch.RESUME_FROM_WATCH";
    private final String ACTION_PAUSE_FROM_WATCH = "com.urbandroid.sleep.watch.PAUSE_FROM_WATCH";
    private final String ACTION_SNOOZE_FROM_WATCH = "com.urbandroid.sleep.watch.SNOOZE_FROM_WATCH";
    private final String ACTION_DISMISS_FROM_WATCH = "com.urbandroid.sleep.watch.DISMISS_FROM_WATCH";

    private final String MAX_RAW_DATA = "MAX_RAW_DATA";
    private final String DATA = "DATA";
    private final String EXTRA_DATA_HR = "com.urbandroid.sleep.EXTRA_DATA_HR";
    private final String EXTRA_DATA_RR = "com.urbandroid.sleep.EXTRA_DATA_RR";
    private final String EXTRA_DATA_SPO2 = "com.urbandroid.sleep.EXTRA_DATA_SPO2";
    private final String EXTRA_DATA_SDNN = "com.urbandroid.sleep.EXTRA_DATA_SDNN";
    private final String EXTRA_DATA_TIMESTAMP = "com.urbandroid.sleep.EXTRA_DATA_TIMESTAMP";
    private final String EXTRA_DATA_FRAMERATE = "com.urbandroid.sleep.EXTRA_DATA_FRAMERATE";
    private final String EXTRA_DATA_BATCH = "com.urbandroid.sleep.EXTRA_DATA_BATCH";


    private GBDevice device;
    private boolean trackingOngoing = false;
    private boolean trackingPaused = false;

    private ScheduledExecutorService trackingPauseScheduler;
    private long batchSize = 1;
    private long lastRawDataMs = 0;
    private float maxRawData = 0;
    private long lastHrDataMs = 0;
    private ArrayList<Float> hrData = new ArrayList<>();

    private ArrayList<Float> accData = new ArrayList<>();
    private ScheduledExecutorService accDataScheduler;
    private Set<SleepAsAndroidFeature> features;

    public SleepAsAndroidSender(GBDevice gbDevice) {
        this.device = gbDevice;
        this.features = gbDevice.getDeviceCoordinator().getSleepAsAndroidFeatures();
    }

    /**
     * Check if a SleepAsAndroid feature is enabled
     *
     * @param feature the feature
     * @return true if the feature is enabled
     */
    public boolean hasFeature(SleepAsAndroidFeature feature) {
        return this.features.contains(feature);
    }

    /**
     * Check if a SleepAsAndroid feature is enabled
     * @param feature
     * @return
     */
    public boolean isFeatureEnabled(SleepAsAndroidFeature feature) {
        boolean enabled = isSleepAsAndroidEnabled();
        if (enabled) {
            switch (feature) {
                case ACCELEROMETER:
                    enabled = GBApplication.getPrefs().getBoolean("pref_key_sleepasandroid_feat_movement", false);
                    break;
                case HEART_RATE:
                    enabled = GBApplication.getPrefs().getBoolean("pref_key_sleepasandroid_feat_hr", false);
                    break;
                case SPO2:
                    enabled = GBApplication.getPrefs().getBoolean("pref_key_sleepasandroid_feat_spo2", false);
                    break;
                case OXIMETRY:
                    enabled = GBApplication.getPrefs().getBoolean("pref_key_sleepasandroid_feat_oximetry", false);
                    break;
                case NOTIFICATIONS:
                    enabled = GBApplication.getPrefs().getBoolean("pref_key_sleepasandroid_feat_notifications", false);
                    break;
                case ALARMS:
                    enabled = GBApplication.getPrefs().getBoolean("pref_key_sleepasandroid_feat_alarms", false);
                    break;
                default:
                    break;
            }
        }
        return enabled;
    }

    /**
     * Get all enabled features
     *
     * @return all enabled features
     */
    public Set<SleepAsAndroidFeature> getFeatures() {
        return features;
    }

    /**
     * Start tracking
     */
    public void startTracking() {
        if (!isDeviceDefault()) return;

        stopTracking();

        accDataScheduler = Executors.newSingleThreadScheduledExecutor();
        accDataScheduler.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                aggregateAndSendAccelData();
            }
        }, 9999, 9999, TimeUnit.MILLISECONDS);

        lastRawDataMs = System.currentTimeMillis();
        lastHrDataMs = System.currentTimeMillis();

        this.trackingOngoing = true;
    }

    /**
     * Stop tracking
     */
    public void stopTracking() {
        if (!isDeviceDefault() || !trackingOngoing) return;
        if (accDataScheduler != null) {
            accDataScheduler.shutdownNow();
            accDataScheduler = null;
        }

        this.trackingOngoing = false;
        this.hrData = new ArrayList<>();
        this.accData = new ArrayList<>();
        this.lastHrDataMs = 0;
        this.lastRawDataMs = 0;
    }

    /**
     * Pause tracking
     *
     * @param timeout the timeout in milliseconds before resuming
     */
    public void pauseTracking(long timeout) {
        if (!isDeviceDefault() || !trackingOngoing) return;

        if (timeout <= 0) {
            resumeTracking();
            return;
        }

        pauseTracking();
        trackingPauseScheduler = setPauseTracking(timeout);
    }

    /**
     * Same as {@link #pauseTracking(long)} but pausing and resuming is controlled by a toggle
     *
     * @param suspended true if the tracking should be paused, false if should be resumed
     */
    public void pauseTracking(boolean suspended) {
        if (!isDeviceDefault() || !trackingOngoing) return;
        trackingPaused = suspended;
        if (!trackingPaused) {
            resumeTracking();
            return;
        }
    }

    /**
     * Set a scheduler to resume tracking
     *
     * @param delay the delay
     * @return the scheduler
     */
    private ScheduledExecutorService setPauseTracking(long delay) {
        trackingPaused = true;
        trackingPauseScheduler = Executors.newSingleThreadScheduledExecutor();
        trackingPauseScheduler.schedule(new Runnable() {
            @Override
            public void run() {
                resumeTracking();
            }
        }, delay, TimeUnit.MILLISECONDS);

        return trackingPauseScheduler;
    }

    /**
     * Pause tracking
     */
    private void pauseTracking() {
        if (!isDeviceDefault() && trackingPaused) return;
        trackingPaused = true;
        stopTracking();
    }

    /**
     * Resume tracking
     */
    private void resumeTracking() {
        if (!isDeviceDefault() && !trackingPaused) return;
        if (trackingPauseScheduler != null) {
            trackingPauseScheduler.shutdownNow();
            trackingPauseScheduler = null;
        }
        trackingPaused = false;
        startTracking();
    }

    /**
     * Set the batch size
     *
     * @param batchSize the batch size
     */
    public void setBatchSize(long batchSize) {
        if (!isDeviceDefault()) return;
        LOG.debug("Setting batch size to " + batchSize);
        this.batchSize = batchSize;
    }

    /**
     * Confirm that the device is connected
     */
    public void confirmConnected() {
        if (!isDeviceDefault()) return;
        LOG.debug("Confirming connected");
        Intent intent = new Intent(SleepAsAndroidAction.CONFIRM_CONNECTED);
        broadcastToSleepAsAndroid(intent);
    }

    /**
     * On accelerometer changed
     *
     * @param x the x value
     * @param y the y value
     * @param z the z value
     */
    public void onAccelChanged(float x, float y, float z) {
        if (!isDeviceDefault() || !isFeatureEnabled(SleepAsAndroidFeature.ACCELEROMETER) || !hasFeature(SleepAsAndroidFeature.ACCELEROMETER) || !trackingOngoing)
            return;
        if (trackingPaused)
            return;

        updateMaxRawData(x, y, z);
    }

    /**
     * Aggregate and send the acceleration data
     */
    private synchronized void aggregateAndSendAccelData() {
        if (!trackingOngoing || trackingPaused) return;
        if (maxRawData > 0) {
            accData.add(maxRawData);
            maxRawData = 0;
            if (accData.size() == batchSize) {
                sendAccelData();
            }
        }
    }

    /**
     * Send the acceleration data
     */
    private void sendAccelData() {
        LOG.debug("Sending movement data: " + this.accData + " batch size: " + batchSize + " array size: " + accData.size());
        Intent intent = new Intent(ACTION_MOVEMENT_DATA_UPDATE);
        intent.putExtra(MAX_RAW_DATA, convertToFloatArray(this.accData));
        accData.clear();
        broadcastToSleepAsAndroid(intent);
    }

    /**
     * Update the max raw data
     * @param x the x value
     * @param y the y value
     * @param z the z value
     */
    private void updateMaxRawData(float x, float y, float z) {
        float maxRaw = calculateAccelerationMagnitude(x, y, z);
        if (maxRaw > maxRawData) {
            maxRawData = maxRaw;
        }
    }

    /**
     * Calculate the acceleration magnitude
     * @param x the x value
     * @param y the y value
     * @param z the z value
     * @return
     */
    protected float calculateAccelerationMagnitude(float x, float y, float z) {
        double sqrt = Math.sqrt((x * x) + (y * y) + (z * z));
        return (float)sqrt;
    }

    /**
     * On heart rate changed
     *
     * @param hr        the heart rate
     * @param sendDelay the send delay in ms. If 0 the data will be send right away. Anything bigger will gather all the data then send it all after the specified interval
     */
    public void onHrChanged(float hr, long sendDelay) {
        if (!isDeviceDefault() || !isFeatureEnabled(SleepAsAndroidFeature.HEART_RATE) || !hasFeature(SleepAsAndroidFeature.HEART_RATE) || !trackingOngoing)
            return;
        if (trackingPaused) return;

        updateLastHrData(hr);

        if (lastHrDataMs == 0) {
            lastHrDataMs = System.currentTimeMillis();
        }
        long ms = System.currentTimeMillis();
        if (ms - lastHrDataMs >= sendDelay) {
            lastHrDataMs = ms;
            sendHrData();
        }
    }

    /**
     * Send the heart rate data
     */
    private synchronized void sendHrData() {
        LOG.debug("Sending heart rate data: " + this.hrData);
        Intent intent = new Intent(ACTION_HEART_RATE_DATA_UPDATE);
        intent.putExtra(DATA, convertToFloatArray(this.hrData));
        broadcastToSleepAsAndroid(intent);
        this.hrData.clear();
    }

    /**
     * Update the last heart rate data
     * @param hr the heart rate
     */
    private void updateLastHrData(float hr) {
        this.hrData.add(hr);
    }

    /**
     * This is a generic intent to carry data from various sensors.
     * See Sleep As Android documentation for parameters values.
     * <a href="https://docs.sleep.urbandroid.org/devs/wearable_api.html#send-various-body-sensors-data-hr-rr-spo2-sdnn">...</a>
     */
    public synchronized void sendExtra(Float hr, Long extraDataTimestamp, Long extraDataFramerate, ArrayList<Float> extraDataRR, ArrayList<Float> spo2Batch, Float sdnn, ArrayList<Float> extraDataBatch) {

        if (!isDeviceDefault() || !trackingOngoing) return;
        if (trackingPaused) return;
        Context context = GBApplication.getContext();
        Intent intent = new Intent(ACTION_EXTRA_DATA_UPDATE);

        // Heart Rate
        if (hr != null && (hasFeature(SleepAsAndroidFeature.HEART_RATE) && isFeatureEnabled(SleepAsAndroidFeature.HEART_RATE))) {
            intent.putExtra(EXTRA_DATA_HR, hr);
        }

        // SpO2
        if (spo2Batch != null && (hasFeature(SleepAsAndroidFeature.SPO2) && isFeatureEnabled(SleepAsAndroidFeature.SPO2))) {
            intent.putExtra(EXTRA_DATA_SPO2, true);
            intent.putExtra(EXTRA_DATA_BATCH, convertToFloatArray(spo2Batch));
        }

        // SDNN
        if (sdnn != null && (hasFeature(SleepAsAndroidFeature.HEART_RATE) && isFeatureEnabled(SleepAsAndroidFeature.HEART_RATE))) {
            intent.putExtra(EXTRA_DATA_SDNN, sdnn);
        }

        // RR Intervals
        if (extraDataRR != null && (hasFeature(SleepAsAndroidFeature.HEART_RATE) && isFeatureEnabled(SleepAsAndroidFeature.HEART_RATE))) {
            intent.putExtra(EXTRA_DATA_RR, convertToFloatArray(extraDataRR));
        }

        if (extraDataBatch != null) {
            if (isDeviceDefault()) {
                for (int i = 0; i < extraDataBatch.size(); i++) {
                    extraDataBatch.set(i, 0.0f);
                }
            }
            intent.putExtra(EXTRA_DATA_BATCH, convertToFloatArray(extraDataBatch));
        }

        if (extraDataTimestamp != null) {
            intent.putExtra(EXTRA_DATA_TIMESTAMP, extraDataTimestamp);
        }
        if (extraDataFramerate != null) {
            intent.putExtra(EXTRA_DATA_FRAMERATE, extraDataFramerate);
        }

        context.sendBroadcast(intent);
    }

    /**
     * This is a generic intent to carry data from various sensors.
     * See Sleep As Android documentation for parameters values.
     * <a href="https://docs.sleep.urbandroid.org/devs/wearable_api.html#send-various-body-sensors-data-hr-rr-spo2-sdnn">...</a>
     */
    public void sendExtra(Float hr, Float extraDataRR, Float spo2, Float sdnn, Long sdnnTimestamp) {

        if (!isDeviceDefault() || !trackingOngoing) return;
        if (trackingPaused) return;
        Intent intent = new Intent(ACTION_EXTRA_DATA_UPDATE);

        // Heart Rate
        if (hr != null && (hasFeature(SleepAsAndroidFeature.HEART_RATE) && isFeatureEnabled(SleepAsAndroidFeature.HEART_RATE))) {
            intent.putExtra(EXTRA_DATA_HR, hr);
        }

        // SpO2
        if (spo2 != null && (hasFeature(SleepAsAndroidFeature.SPO2) && isFeatureEnabled(SleepAsAndroidFeature.SPO2))) {
            intent.putExtra(EXTRA_DATA_SPO2, spo2);
        }

        // SDNN
        if (sdnn != null && (hasFeature(SleepAsAndroidFeature.HEART_RATE) && isFeatureEnabled(SleepAsAndroidFeature.HEART_RATE))) {
            intent.putExtra(EXTRA_DATA_SDNN, sdnn);
        }

        if (extraDataRR != null && (hasFeature(SleepAsAndroidFeature.HEART_RATE) && isFeatureEnabled(SleepAsAndroidFeature.HEART_RATE))) {
            intent.putExtra(EXTRA_DATA_RR, extraDataRR);
        }

        if (sdnnTimestamp != null) {
            intent.putExtra(EXTRA_DATA_TIMESTAMP, sdnnTimestamp);
        }
        broadcastToSleepAsAndroid(intent);
    }

    /**
     * Adds 5 minutes of tracking pause time
     */
    public void sendPauseTracking() {
        if (!isDeviceDefault() || !trackingOngoing) return;
        LOG.debug("Sending pause");
        Intent intent = new Intent(ACTION_PAUSE_FROM_WATCH);
        broadcastToSleepAsAndroid(intent);
    }

    /**
     * Resume tracking
     */
    public void sendResumeTracking() {
        if (!isDeviceDefault() || !trackingOngoing) return;
        LOG.debug("Sending resume");
        Intent intent = new Intent(ACTION_RESUME_FROM_WATCH);
        broadcastToSleepAsAndroid(intent);
    }

    /**
     * Snooze the current alarm
     */
    public void sendSnoozeAlarm() {
        if (!isDeviceDefault()) return;
        if (!hasFeature(SleepAsAndroidFeature.ALARMS) || !isFeatureEnabled(SleepAsAndroidFeature.ALARMS)) return;
        LOG.debug("Sending snooze");
        Intent intent = new Intent(ACTION_SNOOZE_FROM_WATCH);
        broadcastToSleepAsAndroid(intent);
    }

    /**
     * Dismiss the current alarm
     */
    public void sendDismissAlarm() {
        if (!isDeviceDefault()) return;
        if (!hasFeature(SleepAsAndroidFeature.ALARMS) || !isFeatureEnabled(SleepAsAndroidFeature.ALARMS)) return;
        LOG.debug("Sending dismiss");
        Intent intent = new Intent(ACTION_DISMISS_FROM_WATCH);
        broadcastToSleepAsAndroid(intent);
    }

    private void broadcastToSleepAsAndroid(Intent intent) {
        if (!isDeviceDefault()) return;
        intent.setPackage(PACKAGE_SLEEP_AS_ANDROID);
        GBApplication.getContext().sendBroadcast(intent);
    }

    /**
     * Check if the device is set as default provider for Sleep As Android
     *
     * @return true if the device is set as default
     */
    public boolean isDeviceDefault() {
        if (device == null || !device.isInitialized()) return false;
        if (isSleepAsAndroidEnabled()) {
            return device.getAddress().equals(GBApplication.getPrefs().getString("sleepasandroid_device", ""));
        }
        return false;
    }

    public boolean isSleepAsAndroidEnabled() {
        return GBApplication.getPrefs().getBoolean("pref_key_sleepasandroid_enable", false);
    }

    /**
     * Validate if the device is allowed to receive a specific action
     * @param action the action send my the broadcast receiver
     */
    public void validateAction(String action) {
        if (isDeviceDefault()) {
            switch (action) {
                case SleepAsAndroidAction.HINT:
                case SleepAsAndroidAction.SHOW_NOTIFICATION:
                    if (!hasFeature(SleepAsAndroidFeature.NOTIFICATIONS) || !isFeatureEnabled(SleepAsAndroidFeature.NOTIFICATIONS)) {
                        throw new UnsupportedOperationException("Action not valid");
                    }
                    break;
                case SleepAsAndroidAction.START_ALARM:
                case SleepAsAndroidAction.STOP_ALARM:
                case SleepAsAndroidAction.UPDATE_ALARM:
                    if (!hasFeature(SleepAsAndroidFeature.ALARMS) || !isFeatureEnabled(SleepAsAndroidFeature.ALARMS)) {
                        throw new UnsupportedOperationException("Action not valid");
                    }
                    break;
                case SleepAsAndroidAction.START_TRACKING:
                case SleepAsAndroidAction.STOP_TRACKING:
                case SleepAsAndroidAction.SET_BATCH_SIZE:
                    if (!hasFeature(SleepAsAndroidFeature.ACCELEROMETER) || !isFeatureEnabled(SleepAsAndroidFeature.ACCELEROMETER)) {
                        throw new UnsupportedOperationException("Action not valid");
                    }
                    break;
                default:
                    break;
            }
        } else {
            throw new UnsupportedOperationException("Action not valid");
        }
    }

    /**
     * Convert an ArrayList to a float array
     *
     * @param list the ArrayList
     * @return the float array
     */
    private float[] convertToFloatArray(ArrayList<Float> list) {
        float[] result = new float[list.size()];
        int i = 0;
        for (float f : list) {
            result[i++] = f;
        }
        return result;
    }

    /**
     * Get configured alarm slot
     *
     * @return the alarm slot to be used for setting alarms on the watch
     */
    public static int getAlarmSlot() {
        Prefs prefs = GBApplication.getPrefs();
        String slotString = prefs.getString("sleepasandroid_alarm_slot", "");
        if (!slotString.isEmpty()) {
            return Integer.parseInt(slotString);
        }
        return 0;
    }
}