/*
 * Copyright (C) Cross The Road Electronics.  All rights reserved.
 * License information can be found in CTRE_LICENSE.txt
 * For support and suggestions contact support@ctr-electronics.com or file
 * an issue tracker at https://github.com/CrossTheRoadElec/Phoenix-Releases
 */
package com.ctre.phoenix6;

import java.util.Map;
import java.util.function.DoubleFunction;
import java.util.function.Supplier;

import com.ctre.phoenix6.Timestamp.TimestampSource;
import com.ctre.phoenix6.hardware.DeviceIdentifier;
import com.ctre.phoenix6.hardware.ParentDevice.MapGenerator;
import com.ctre.phoenix6.jni.ErrorReportingJNI;

import edu.wpi.first.units.Measure;

/**
 * Represents a status signal with data of type T, and
 * operations available to retrieve information about
 * the signal.
 */
public class StatusSignal<T> extends BaseStatusSignal implements Cloneable {
    private final Class<T> classOfSignal;
    private final DoubleFunction<T> toValue;

    private final Map<Integer, String> _unitStrings;
    private int _unitsKey;

    public StatusSignal(
        DeviceIdentifier deviceIdentifier, int spn, Runnable reportIfOldFunc,
        Class<T> classOfSignal, DoubleFunction<T> toValue, String signalName
    ) {
        super(deviceIdentifier, spn, signalName, reportIfOldFunc);
        this.classOfSignal = classOfSignal;
        this.toValue = toValue;
        this._unitStrings = null;
        this._unitsKey = spn;
    }

    public StatusSignal(
        DeviceIdentifier deviceIdentifier, int spn, Runnable reportIfOldFunc,
        Class<T> classOfSignal, DoubleFunction<T> toValue,
        MapGenerator<T> generator, String signalName
    ) {
        super(deviceIdentifier, spn, signalName, reportIfOldFunc);
        this.classOfSignal = classOfSignal;
        this.toValue = toValue;
        this._unitStrings = generator.run();
        this._unitsKey = spn;

        var tmpJni = jni.clone();
        for (var unitString : _unitStrings.entrySet()) {
            tmpJni.spn = unitString.getKey();
            unitString.setValue(tmpJni.JNI_GetUnits());
        }
    }

    /* Constructor for an invalid StatusSignal */
    public StatusSignal(Class<T> classOfSignal, DoubleFunction<T> toValue, StatusCode error) {
        super(error);
        this.classOfSignal = classOfSignal;
        this.toValue = toValue;
        this._unitStrings = null;
        this._unitsKey = spn;
    }

    @Override
    protected void updateUnits(int unitsKey) {
        if (_unitsKey != unitsKey && _unitStrings != null && _unitStrings.containsKey(unitsKey)) {
            units = _unitStrings.get(unitsKey);
            _unitsKey = unitsKey;
        }
    }

    /**
     * Returns a lambda that calls {@link #refresh} and {@link #getValue} on this object.
     * This is useful for command-based programming.
     *
     * @return Supplier that refreshes this signal and returns it
     */
    public Supplier<T> asSupplier() {
        return () -> refresh().getValue();
    }

    /**
     * Information from a single measurement of a status signal.
     */
    public static class SignalMeasurement<L> {
        /**
         * The value of the signal
         */
        public L value;
        /**
         * Timestamp of when the data point was taken, in seconds
         */
        public double timestamp;
        /**
         * Status code response of getting the data
         */
        public StatusCode status;
        /**
         * Units that correspond to this point
         */
        public String units;
    };

    @Override
    public String toString() {
        var value = getValue();
        if (value == null || units == null) {
            return "Invalid signal";
        } else if (value instanceof Measure) {
            return getValueAsDouble() + " " + units;
        } else {
            return value.toString() + " " + units;
        }
    }

    @Override
    public StatusSignal<T> clone() {
        try {
            @SuppressWarnings("unchecked")
            StatusSignal<T> toReturn = StatusSignal.class.cast(super.clone());
            toReturn.timestamps = timestamps.clone();
            toReturn.jni = jni.clone();
            return toReturn;
        } catch (CloneNotSupportedException ex) {
            /* this should never happen */
            return new StatusSignal<T>(classOfSignal, toValue, StatusCode.InvalidParamValue);
        }
    }

    public Class<T> getTypeClass() {
        return classOfSignal;
    }

    /**
     * Gets the cached value from this status signal.
     * <p>
     * Gets the cached value. To make sure the value is up-to-date call
     * {@link #refresh()} or {@link #waitForUpdate(double)}
     *
     * @return Cached value
     */
    public T getValue() {
        return toValue.apply(baseValue);
    }

    private void updateValue(boolean waitForSignal, double timeout, boolean reportError) {
        _reportIfOldFunc.run();

        if (waitForSignal) {
            error = StatusCode.valueOf(jni.JNI_WaitForSignal(timeout));
        } else {
            error = StatusCode.valueOf(jni.JNI_RefreshSignal(timeout));
        }
        baseValue = jni.value;
        timestamps.update(
            jni.swtimeStampSeconds, TimestampSource.System, true,
            jni.hwtimeStampSeconds, TimestampSource.CANivore, true,
            jni.ecutimeStampSeconds, TimestampSource.Device, jni.ecutimeStampSeconds != 0.0
        );
        updateUnits(jni.unitsKey);

        if (reportError && !this.error.isOK()) {
            String device = this.deviceIdentifier.toString() + " Status Signal " + this.signalName;
            ErrorReportingJNI.reportStatusCode(this.error.value, device);
        }
    }

    /**
     * Refreshes the value of this status signal.
     * <p>
     * If the user application caches this StatusSignal object
     * instead of periodically fetching it from the hardware device,
     * this function must be called to fetch fresh data.
     * <p>
     * This performs a non-blocking refresh operation. If you want to wait until you
     * receive the signal, call {@link #waitForUpdate(double)} instead.
     *
     * @param reportError Whether to report any errors to the Driver Station/stderr.
     *                    Defaults true
     *
     * @return Reference to itself
     */
    public StatusSignal<T> refresh(boolean reportError) {
        updateValue(false, 0, reportError); // Don't block and error if signal is older than a default timeout
        return this;
    }

    /**
     * Refreshes the value of this status signal.
     * <p>
     * If the user application caches this StatusSignal object
     * instead of periodically fetching it from the hardware device,
     * this function must be called to fetch fresh data.
     * <p>
     * This performs a non-blocking refresh operation. If you want to wait until you
     * receive the signal, call {@link #waitForUpdate(double)} instead.
     *
     * @return Reference to itself
     */
    public StatusSignal<T> refresh() {
        return refresh(true);
    }

    /**
     * Waits up to timeoutSec to get the up-to-date status signal value.
     * <p>
     * This performs a blocking refresh operation. If you want to non-blocking
     * refresh the signal, call {@link #refresh()} instead.
     *
     * @param timeoutSec  Maximum time to wait for the signal to update
     * @param reportError Whether to report any errors to the Driver Station/stderr.
     *                    Defaults true
     *
     * @return Reference to itself
     */
    public StatusSignal<T> waitForUpdate(double timeoutSec, boolean reportError) {
        updateValue(true, timeoutSec, reportError);
        return this;
    }

    /**
     * Waits up to timeoutSec to get the up-to-date status signal value.
     * <p>
     * This performs a blocking refresh operation. If you want to non-blocking
     * refresh the signal, call {@link #refresh()} instead.
     *
     * @param timeoutSec Maximum time to wait for the signal to update
     *
     * @return Reference to itself
     */
    public StatusSignal<T> waitForUpdate(double timeoutSec) {
        return waitForUpdate(timeoutSec, true);
    }

    /**
     * Get a basic data-only container with this information, to be used for things
     * such as data logging.
     * <p>
     * Note if looking for Phoenix 6 logging features, see the {@link SignalLogger}
     * class instead.
     * <p>
     * This function returns a new object every call. As a result, we recommend that
     * this is not called inside a tight loop.
     *
     * @return Basic structure with all relevant information
     */
    public SignalMeasurement<T> getDataCopy() {
        SignalMeasurement<T> toRet = new SignalMeasurement<T>();
        toRet.value = getValue();
        toRet.status = getStatus();
        toRet.units = getUnits();
        toRet.timestamp = getTimestamp().getTime();
        return toRet;
    }
}