/*
 * 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.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
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;

/**
 * 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 Class<T> classOfSignal;
    private boolean _containsUnderlyingTypes;
    private Map<Integer, StatusSignal<T>> _basicTypeMap;

    public StatusSignal(DeviceIdentifier deviceIdentifier, int spn, Runnable reportIfOldFunc,
            Class<T> classOfSignal, String signalName) {
        super(deviceIdentifier, spn, signalName, reportIfOldFunc);
        this.classOfSignal = classOfSignal;
        _containsUnderlyingTypes = false;
        _basicTypeMap = null;
    }

    public StatusSignal(DeviceIdentifier deviceIdentifier, int spn, Runnable reportIfOldFunc,
            Class<T> classOfSignal,
            MapGenerator<T> generator, String signalName) {
        super(deviceIdentifier, spn, signalName, reportIfOldFunc);
        this.classOfSignal = classOfSignal;
        _containsUnderlyingTypes = true;
        _basicTypeMap = generator.run();
    }

    /* Constructor for an invalid StatusSignal */
    public StatusSignal(Class<T> classOfSignal, StatusCode error) {
        super(error);
        this.classOfSignal = classOfSignal;
        _containsUnderlyingTypes = false;
        _basicTypeMap = null;
    }

    /**
     * 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 () -> {
            return refresh().getValue();
        };
    }

    /**
     * Information from a single measurement of a status signal.
     */
    public static class SignalMeasurement<L> {
        /**
         * The value of the signal, this may be an enum so it is stored as a string
         */
        public L value;
        /**
         * Timestamp of when the data point was taken
         */
        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() {
        if (getValue() != null && units != null)
            return getValue().toString() + " " + units;
        return "Invalid signal";
    }

    @Override
    public StatusSignal<T> clone() {
        try {
            @SuppressWarnings("unchecked")
            StatusSignal<T> toReturn = StatusSignal.class.cast(super.clone());
            toReturn.timestamps = timestamps.clone();
            toReturn.jni = jni.clone();

            if (_basicTypeMap != null) {
                toReturn._basicTypeMap = new HashMap<>();
                for (var entry : _basicTypeMap.entrySet()) {
                    toReturn._basicTypeMap.put(entry.getKey(), entry.getValue().clone());
                }
            }
            return toReturn;
        } catch (CloneNotSupportedException ex) {
            /* this should never happen */
            return new StatusSignal<T>(classOfSignal, 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() {
        if (classOfSignal.equals(Double.class)) {
            return classOfSignal.cast(baseValue);
        } else if (classOfSignal.equals(Integer.class)) {
            return classOfSignal.cast((int) baseValue);
        } else if (classOfSignal.equals(Boolean.class)) {
            return classOfSignal.cast(baseValue != 0 ? true : false);
        } else if (classOfSignal.isEnum()) {
            try {
                /* This is an enum, so it contains a valueOf class method that we can invoke instead */
                return classOfSignal.cast(classOfSignal.getMethod("valueOf", Integer.TYPE).invoke(null, (int)baseValue));
            } catch (IllegalAccessException excep) {
                /* valueOf is not accessible */
                error = StatusCode.CouldNotCast;
            } catch (IllegalArgumentException excep) {
                /* Invalid valueOf argument */
                error = StatusCode.CouldNotCast;
            } catch (InvocationTargetException excep) {
                /* Could not invoke valueOf on this enum */
                error = StatusCode.CouldNotCast;
            } catch (NoSuchMethodException excep) {
                /* valueOf with parameter of int is not available for this enum */
                error = StatusCode.CouldNotCast;
            } catch (ClassCastException excep) {
                /* The valueOf return didn't match the class type that we need to return */
                error = StatusCode.CouldNotCast;
            }
        } else {
            /* Try to cast it, I guess */
            try {
                return classOfSignal.cast(baseValue);
            } catch (ClassCastException excep) {
                /* Cast failed, do something I guess */
                error = StatusCode.CouldNotCast;
            }
        }
        return null;
    }

    private void refreshMappable(boolean waitForSignal, double timeout) {
        if (!_containsUnderlyingTypes)
            return;
        if (waitForSignal) {
            error = StatusCode.valueOf(jni.JNI_WaitForSignal(timeout));
        } else {
            error = StatusCode.valueOf(jni.JNI_RefreshSignal(timeout));
        }

        if (_basicTypeMap.containsKey((int) jni.value)) {
            StatusSignal<T> gottenValue = _basicTypeMap.get((int) jni.value);
            gottenValue.updateValue(waitForSignal, timeout, false);
            /* no lock needed, pointer and primitive copies are atomic */
            copyFrom(gottenValue);
        }
    }

    private void refreshNonmappable(boolean waitForSignal, double timeout) {
        if (_containsUnderlyingTypes)
            return;
        if (waitForSignal) {
            error = StatusCode.valueOf(jni.JNI_WaitForSignal(timeout));
        } else {
            error = StatusCode.valueOf(jni.JNI_RefreshSignal(timeout));
        }
        if (error.isError()) { // don't update on an error
            return;
        }
        baseValue = jni.value;
        timestamps.update(jni.swtimeStampSeconds, TimestampSource.System, true,
                jni.hwtimeStampSeconds, TimestampSource.CANivore, true,
                jni.ecutimeStampSeconds, TimestampSource.Device, jni.ecutimeStampSeconds != 0.0);
    }

    private void updateValue(boolean waitForSignal, double timeout, boolean reportError) {
        _reportIfOldFunc.run();
        if (_containsUnderlyingTypes) {
            refreshMappable(waitForSignal, timeout);
        } else {
            refreshNonmappable(waitForSignal, timeout);
        }
        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);
    }

    /**
     * Sets the rate at which the device will publish this signal.
     * <p>
     * A frequency of 0 Hz will turn off the signal. Otherwise, the minimum supported signal
     * frequency is 4 Hz, and the maximum is 1000 Hz.
     * <p>
     * If other StatusSignals in the same status frame have been set to an update frequency,
     * the fastest requested update frequency will be applied to the frame.
     *
     * @param frequencyHz Rate to publish the signal in Hz.
     * @param timeoutSeconds Maximum amount of time to wait when performing the action
     * @return Status code of setting the update frequency
     */
    @Override
    public StatusCode setUpdateFrequency(double frequencyHz, double timeoutSeconds) {
        if (_containsUnderlyingTypes) {
            return _basicTypeMap.values().iterator().next().setUpdateFrequency(frequencyHz, timeoutSeconds);
        } else {
            return StatusCode.valueOf(jni.JNI_SetUpdateFrequency(frequencyHz, timeoutSeconds));
        }
    }

    /**
     * Gets the rate at which the device will publish this signal.
     * <p>
     * This is typically the last value passed into {@link #setUpdateFrequency}. The returned value
     * may be higher if another StatusSignal in the same status frame has been set to a higher
     * update frequency.
     *
     * @return Applied update frequency of the signal in Hz
     */
    @Override
    public double getAppliedUpdateFrequency() {
        if (_containsUnderlyingTypes) {
            return _basicTypeMap.values().iterator().next().getAppliedUpdateFrequency();
        } else {
            return jni.JNI_GetAppliedUpdateFrequency();
        }
    }

    /**
     * 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;
    }
}