/*  Copyright (C) 2020-2024 Arjan Schrijver, Taavi Eomäe

    This file is part of Gadgetbridge.

    Gadgetbridge is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published
    by the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Gadgetbridge is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>. */
package nodomain.freeyourgadget.gadgetbridge.service.devices.nut;

import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCharacteristic;
import android.content.Intent;
import android.content.SharedPreferences;
import android.widget.Toast;

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

import java.math.BigInteger;
import java.util.Arrays;
import java.util.Map;
import java.util.UUID;

import nodomain.freeyourgadget.gadgetbridge.GBApplication;
import nodomain.freeyourgadget.gadgetbridge.deviceevents.GBDeviceEventBatteryInfo;
import nodomain.freeyourgadget.gadgetbridge.deviceevents.GBDeviceEventVersionInfo;
import nodomain.freeyourgadget.gadgetbridge.devices.nut.NutConstants;
import nodomain.freeyourgadget.gadgetbridge.devices.nut.NutKey;
import nodomain.freeyourgadget.gadgetbridge.impl.GBDevice;
import nodomain.freeyourgadget.gadgetbridge.service.btle.AbstractBTLEDeviceSupport;
import nodomain.freeyourgadget.gadgetbridge.service.btle.TransactionBuilder;
import nodomain.freeyourgadget.gadgetbridge.service.btle.actions.SetDeviceStateAction;
import nodomain.freeyourgadget.gadgetbridge.service.btle.profiles.IntentListener;
import nodomain.freeyourgadget.gadgetbridge.service.btle.profiles.battery.BatteryInfo;
import nodomain.freeyourgadget.gadgetbridge.service.btle.profiles.battery.BatteryInfoProfile;
import nodomain.freeyourgadget.gadgetbridge.service.btle.profiles.deviceinfo.DeviceInfo;
import nodomain.freeyourgadget.gadgetbridge.service.btle.profiles.deviceinfo.DeviceInfoProfile;
import nodomain.freeyourgadget.gadgetbridge.util.GB;

public class NutSupport extends AbstractBTLEDeviceSupport {
    private static final Logger LOG = LoggerFactory.getLogger(NutSupport.class);

    private final GBDeviceEventBatteryInfo batteryCmd = new GBDeviceEventBatteryInfo();

    private final DeviceInfoProfile<NutSupport> deviceInfoProfile;
    private final BatteryInfoProfile<NutSupport> batteryInfoProfile;
    private final IntentListener listener = new IntentListener() {
        @Override
        public void notify(Intent intent) {
            String action = intent.getAction();
            if (action.equals(DeviceInfoProfile.ACTION_DEVICE_INFO)) {
                handleDeviceInfo((DeviceInfo) intent.getParcelableExtra(DeviceInfoProfile.EXTRA_DEVICE_INFO));
            } else if (action.equals(BatteryInfoProfile.ACTION_BATTERY_INFO)) {
                handleBatteryInfo((BatteryInfo) intent.getParcelableExtra(BatteryInfoProfile.EXTRA_BATTERY_INFO));
            } else {
                LOG.warn("Unhandled intent given to listener");
            }
        }
    };
    private SharedPreferences prefs = null;
    /**
     * It uses the proprietary Nut interface.
     */
    private boolean proprietary = false;
    /**
     * Proprietary Nut interface needs authentication.
     * <p>
     * Don't write characteristics until authenticated.
     * <p>
     * Will disconnect in a minute if you don't authenticate.
     */
    private boolean authenticated = true;
    /**
     * The two keys used for authentication
     */
    private BigInteger key1;
    private BigInteger key2;


    public NutSupport() {
        super(LOG);
        addSupportedService(NutConstants.SERVICE_BATTERY);
        addSupportedService(NutConstants.SERVICE_DEVICE_INFO);
        addSupportedService(NutConstants.SERVICE_IMMEDIATE_ALERT);
        addSupportedService(NutConstants.SERVICE_LINK_LOSS);
        addSupportedService(NutConstants.SERVICE_PROPRIETARY_NUT);
        addSupportedService(NutConstants.SERVICE_UNKNOWN_2);

        deviceInfoProfile = new DeviceInfoProfile<>(this);
        deviceInfoProfile.addListener(listener);
        addSupportedProfile(deviceInfoProfile);

        batteryInfoProfile = new BatteryInfoProfile<>(this);
        batteryInfoProfile.addListener(listener);
        addSupportedProfile(batteryInfoProfile);
    }

    private void handleBatteryInfo(BatteryInfo info) {
        LOG.info("Received Nut battery info");
        batteryCmd.level = (short) info.getPercentCharged();
        handleGBDeviceEvent(batteryCmd);
    }

    private void handleDeviceInfo(DeviceInfo info) {
        LOG.info("Received Nut device info");
        LOG.info(String.valueOf(info));
        GBDeviceEventVersionInfo versionInfo = new GBDeviceEventVersionInfo();
        if (info.getHardwareRevision() != null) {
            versionInfo.hwVersion = info.getHardwareRevision();
        }
        if (info.getFirmwareRevision() != null) {
            versionInfo.fwVersion = info.getFirmwareRevision();
        }

        handleGBDeviceEvent(versionInfo);
    }

    @Override
    protected TransactionBuilder initializeDevice(TransactionBuilder builder) {
        builder.add(new SetDeviceStateAction(getDevice(), GBDevice.State.INITIALIZING, getContext()));
        builder.add(new SetDeviceStateAction(getDevice(), GBDevice.State.INITIALIZED, getContext()));

        // Init prefs
        prefs = GBApplication.getDeviceSpecificSharedPrefs(getDevice().getAddress());
        loadKeysFromPrefs();

        LOG.debug("Requesting device info!");
        deviceInfoProfile.requestDeviceInfo(builder);
        batteryInfoProfile.requestBatteryInfo(builder);

        // If this characteristic exists, it has proprietary Nut interface
        this.proprietary = (getCharacteristic(NutConstants.CHARAC_AUTH_STATUS) != null);

        if (proprietary) {
            this.authenticated = false;
            /**
             * Part of {@link NutConstants.SERVICE_PROPRIETARY_NUT}
             * Enables proprietary notification
             */
            builder.notify(getCharacteristic(NutConstants.CHARAC_AUTH_STATUS), true);
            LOG.info("Enabled authentication status notify");

            /**
             * Part of {@link NutConstants.SERVICE_UNKNOWN_2}
             * Enables button-press notify
             */
            builder.notify(getCharacteristic(NutConstants.CHARAC_UNKNOWN_2), true);
        } else {
            /**
             * Part of {@link NutConstants.SERVICE_UNKNOWN_1_WEIRDNESS}
             * Enables button-press notify
             */
            builder.notify(getCharacteristic(NutConstants.CHARAC_CHANGE_POWER), true);
        }

        readDeviceInfo();
        return builder;
    }

    @Override
    public boolean useAutoConnect() {
        return true;
    }

    @Override
    public void onFindDevice(boolean enable) {
        deviceImmediateAlert(enable);
    }

    @Override
    public boolean onCharacteristicChanged(BluetoothGatt gatt,
                                           BluetoothGattCharacteristic characteristic) {
        if (super.onCharacteristicChanged(gatt, characteristic)) {
            return true;
        }

        UUID characteristicUUID = characteristic.getUuid();
        if (characteristicUUID.equals(NutConstants.CHARAC_AUTH_STATUS)) {
            handleAuthResult(characteristic.getValue());
            return true;
        }
        LOG.info("Unhandled characteristic changed: " + characteristicUUID);
        return false;
    }

    @Override
    public boolean onCharacteristicRead(BluetoothGatt gatt,
                                        BluetoothGattCharacteristic characteristic,
                                        int status) {
        if (super.onCharacteristicRead(gatt, characteristic, status)) {
            return true;
        }
        UUID characteristicUUID = characteristic.getUuid();

        if (characteristicUUID.equals(NutConstants.CHARAC_SYSTEM_ID)) {
            // TODO: Handle System ID read
            return true;
        }
        LOG.info("Unhandled characteristic read: " + characteristicUUID);
        return false;
    }

    /**
     * Enables or disables link loss alert
     */
    private void deviceLinkLossAlert(boolean enable) {
        UUID charac;
        if (this.proprietary) {
            /** Part of {@link NutConstants.SERVICE_PROPRIETARY_NUT} */
            charac = NutConstants.CHARAC_CHANGE_POWER;
        } else {
            /** Part of {@link NutConstants.SERVICE_IMMEDIATE_ALERT} */
            charac = NutConstants.CHARAC_LINK_LOSS_ALERT_LEVEL;
        }

        byte[] payload = new byte[]{(byte) (enable ? 0x00 : 0x01)};
        if (enable) {
            writeCharacteristic("Enable link loss alert", charac, payload);
        } else {
            writeCharacteristic("Disable link loss alert", charac, payload);
        }
    }

    /**
     * Should trigger an immediate alert
     *
     * @param enable turn on or not
     */
    private void deviceImmediateAlert(boolean enable) {
        UUID charac;
        if (this.proprietary) {
            /** Part of {@link NutConstants.SERVICE_IMMEDIATE_ALERT} */
            charac = NutConstants.CHARAC_LINK_LOSS_ALERT_LEVEL;
            if (!authenticated) {
                LOG.warn("Not authenticated, can't alert");
                return;
            }
        } else {
            /** Part of {@link NutConstants.SERVICE_PROPRIETARY_NUT} */
            charac = NutConstants.CHARAC_CHANGE_POWER;
        }

        if (enable) {
            writeCharacteristic("Start alert", charac, new byte[]{(byte) 0x04});
        } else {
            writeCharacteristic("Stop alert", charac, new byte[]{(byte) 0x03});
        }
    }

    /**
     * This will write a new key to the device
     * <p>
     * However, <b>it is irreversible</b>,
     * if you can't generate the right packets,
     * the device is basically bricked!
     * <p>
     * If you can generate the correct packets,
     * it can be reset... somehow
     *
     * @param key key
     */
    private void deviceWriteNewKey(byte[] key) {
        // TODO: Determine each nuance of how this
        //  works before using it!
        byte[] result_payload = new byte[key.length + 1];
        result_payload[0] = (byte) 0x04;
        System.arraycopy(key, 0, result_payload, 1, key.length);

        writeCharacteristic("Write new key",
                NutConstants.CHARAC_DFU_PW,
                result_payload);
    }

    /**
     * Turns the device off
     */
    private void deviceShutdown() {
        writeCharacteristic("Shutdown", NutConstants.CHARAC_CHANGE_POWER, new byte[]{0x06});
    }

    /**
     * Switches the device to Nordic's DFU mode
     */
    private void deviceDFU() {
        writeCharacteristic("Enable DFU mode", NutConstants.CHARAC_DFU_PW, new byte[]{0x14});
    }

    /**
     * Specifies how long the alert lasts
     *
     * @param duration in seconds (I think)
     */
    private void deviceWriteAlertDuration(int duration) {
        if (duration == 0) {
            duration = 15;
        }

        UUID charac;
        if (this.proprietary) {
            charac = NutConstants.CHARAC_DFU_PW;
        } else {
            charac = NutConstants.CHARAC_CHANGE_POWER;
        }

        writeCharacteristic("Write alert duration",
                charac,
                new byte[]{37, (byte) duration});
    }

    private void readHardwareInfo() {
        BluetoothGattCharacteristic characteristic = getCharacteristic(NutConstants.CHARAC_HARDWARE_VERSION);
        if (characteristic != null &&
                ((characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) > 0)) {
            readCharacteristic("Device read hardware",
                    NutConstants.CHARAC_HARDWARE_VERSION);
        }

        BluetoothGattCharacteristic characteristic1 = getCharacteristic(NutConstants.CHARAC_MANUFACTURER_NAME);
        if (characteristic1 != null &&
                (characteristic1.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
            readCharacteristic("Read manufacturer",
                    NutConstants.CHARAC_MANUFACTURER_NAME);
        }
    }

    private void readFirmwareInfo() {
        BluetoothGattCharacteristic characteristic = getCharacteristic(NutConstants.CHARAC_FIRMWARE_VERSION);
        if (characteristic != null &&
                (characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
            readCharacteristic("Read firmware version",
                    NutConstants.CHARAC_FIRMWARE_VERSION);
        }
    }

    private void readBatteryInfo() {
        BluetoothGattCharacteristic characteristic = getCharacteristic(NutConstants.CHARAC_BATTERY_INFO);
        if (characteristic != null &&
                (characteristic.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) > 0) {
            readCharacteristic("Read battery info",
                    NutConstants.CHARAC_BATTERY_INFO);
        }
    }

    /**
     * Loads the three keys from device-specific shared preferences
     */
    private void loadKeysFromPrefs() {
        if (prefs != null) {
            LOG.info("Reading keys");
            key1 = new BigInteger(prefs.getString("nut_packet_key_1", "0"));
            key2 = new BigInteger(prefs.getString("nut_packet_key_2", "0"));
            if (key1.equals(BigInteger.ZERO) || key2.equals(BigInteger.ZERO)) {
                byte[] challenge = NutKey.hexStringToByteArrayNut(prefs.getString("nut_packet_challenge", "00"));
                byte[] response = NutKey.hexStringToByteArrayNut(prefs.getString("nut_response_challenge", "00"));
                if (Arrays.equals(challenge, new byte[]{0x00}) ||
                        Arrays.equals(response, new byte[]{0x00})) {
                    GB.toast("No key available for the device", Toast.LENGTH_LONG, GB.ERROR);
                    return;
                }
                Map.Entry<BigInteger, BigInteger> key = NutKey.reversePasswordGeneration(
                        challenge,
                        response,
                        gbDevice.getAddress()
                );
                if (key == null) {
                    GB.toast("No correct key available for the device", Toast.LENGTH_LONG, GB.ERROR);
                    return;
                }
                key1 = key.getKey();
                key2 = key.getValue();
                LOG.debug("Key was extracted from challenge-response packets");
            } else {
                LOG.debug("Key was preset");
            }
        }
    }

    /**
     * Processes the authentication flow of the proprietary Nut protocol
     * See more: {@link NutConstants#SERVICE_PROPRIETARY_NUT}
     *
     * @param received the notify characteristic's content
     */
    public final void handleAuthResult(byte[] received) {
        if (received != null && received.length != 0) {
            if (received[0] == 0x01) {
                // Password is needed
                // Preamble, counter, rotating key, static key
                byte[] payload = new byte[1 + 1 + 3 + 12];

                // This is a response to the challenge
                payload[0] = 0x02;

                // Modify the challenge
                byte[] response = NutKey.passwordGeneration(gbDevice.getAddress(), received, key1, key2);
                System.arraycopy(response, 0, payload, 1, response.length);

                writeCharacteristic("Authentication",
                        NutConstants.CHARAC_DFU_PW,
                        payload
                );
                LOG.debug("Successfully sent auth");
            } else if (received[0] == 0x03) {
                if (received[1] == 0x55) {
                    LOG.debug("Successful password attempt or uninitialized");
                    authenticated = true;
                    initChara();
                } else {
                    LOG.debug("Error authenticating");
                    // TODO: Disconnect
                }
            } else if (received[0] == 0x05) {
                LOG.debug("Password has been set");
            } else {
                LOG.debug("Invalid packet");
                // TODO: Disconnect
            }
        }
    }

    /**
     * Initializes required characteristics
     */
    private void initChara() {
        if (proprietary) {
            writeCharacteristic("Init alert 1", NutConstants.CHARAC_LINK_LOSS_ALERT_LEVEL, new byte[]{(byte) 0x00});
            writeCharacteristic("Init alert 2", NutConstants.CHARAC_LINK_LOSS_ALERT_LEVEL, new byte[]{(byte) 0x00});
            writeCharacteristic("Init alert 3", NutConstants.CHARAC_LINK_LOSS_ALERT_LEVEL, new byte[]{(byte) 0x00});
        }
    }

    /**
     * Initiates a read of all the device information characteristics
     */
    private void readDeviceInfo() {
        readBatteryInfo();
        readHardwareInfo();
        readFirmwareInfo();
    }

    /**
     * Just wraps writing into a neat little function
     *
     * @param taskName something that describes the task a bit
     * @param charac   the characteristic to write
     * @param data     the data to write
     */
    private void writeCharacteristic(String taskName, UUID charac, byte[] data) {
        BluetoothGattCharacteristic characteristic = getCharacteristic(charac);

        TransactionBuilder builder = new TransactionBuilder(taskName);
        builder.write(characteristic, data);
        builder.queue(getQueue());
    }

    /**
     * Just wraps reading into a neat little function
     *
     * @param taskName something that describes the task a bit
     * @param charac   the characteristic to read
     */
    private void readCharacteristic(String taskName, UUID charac) {
        BluetoothGattCharacteristic characteristic = getCharacteristic(charac);

        TransactionBuilder builder = new TransactionBuilder(taskName);
        builder.read(characteristic);
        builder.queue(getQueue());
    }

    @Override
    public boolean getImplicitCallbackModify() {
        return true;
    }

    @Override
    public boolean getSendWriteRequestResponse() {
        return false;
    }
}