/*
 * 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.phoenixpro;

import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.function.Supplier;

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

public class StatusSignalValue<T> extends BaseStatusSignalValue implements Cloneable {
    private Class<T> classOfSignal;
    private boolean _containsUnderlyingTypes;
    private Map<Integer, StatusSignalValue<T>> _basicTypeMap;
    private Runnable _reportIfOldFunc;

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

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

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

    /**
     * Returns a lambda that calls Refresh and 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();
        };
    }

    public 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;
        /**
         * Code response of getting the data
         */
        public StatusCode error;
        /**
         * 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 StatusSignalValue<T> clone() {
        try {
            @SuppressWarnings("unchecked")
            StatusSignalValue<T> toReturn = StatusSignalValue.class.cast(super.clone());
            toReturn.jni = jni.clone();
            return toReturn;
        } catch (CloneNotSupportedException ex) {
            /* this should never happen */
            return new StatusSignalValue<T>(classOfSignal, StatusCode.InvalidParamValue);
        }
    }

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

    /**
     * Gets the cached value from this status signal value
     * <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(deviceIdentifier.getNetwork(), timeout));
        } else {
            error = StatusCode.valueOf(jni.JNI_RefreshSignal(deviceIdentifier.getNetwork(), timeout));
        }

        if (_basicTypeMap.containsKey((int) jni.value)) {
            StatusSignalValue<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(deviceIdentifier.getNetwork(), timeout));
        } else {
            error = StatusCode.valueOf(jni.JNI_RefreshSignal(deviceIdentifier.getNetwork(), timeout));
        }
        units = jni.units;
        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,
                0, null, false);
    }

    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 Value " + this.signalName;
            ErrorReportingJNI.reportStatusCode(this.error.value, device);
        }
    }

    /**
     * Refreshes this status signal value
     * <p>
     * If the user application caches this StatusSignalValue 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 StatusSignalValue<T> refresh(boolean reportError) {
        updateValue(false, 0.300, reportError);
        return this;
    }

    /**
     * Refreshes this status signal value
     * <p>
     * If the user application caches this StatusSignalValue 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 StatusSignalValue<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 come in
     * @param reportError Whether to report any errors to the Driver Station/stderr.
     *                    Defaults true
     *
     * @return Reference to itself
     */
    public StatusSignalValue<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 come in
     *
     * @return Reference to itself
     */
    public StatusSignalValue<T> waitForUpdate(double timeoutSec) {
        return waitForUpdate(timeoutSec, true);
    }

    /**
     * Sets the rate at which the device will publish this signal.
     * <p>
     * The minimum supported signal frequency is 4 Hz, and the maximum is 1000 Hz.
     * <p>
     * This will wait up to 0.050 seconds (50ms) by default.
     *
     * @param frequencyHz Rate to publish the signal in Hz.
     * @return Status code of setting the update frequency
     */
    public StatusCode setUpdateFrequency(double frequencyHz) {
        return setUpdateFrequency(frequencyHz, 0.050);
    }

    /**
     * Sets the rate at which the device will publish this signal.
     * <p>
     * The minimum supported signal frequency is 4 Hz, and the maximum is 1000 Hz.
     *
     * @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
     */
    public StatusCode setUpdateFrequency(double frequencyHz, double timeoutSeconds) {
        /* attempt to change the period */
        return StatusCode.valueOf(jni.JNI_SetUpdateFrequency(this.deviceIdentifier.getNetwork(), frequencyHz, timeoutSeconds));
    }

    /**
     * Get a basic data-only container with this information, to be used for things
     * such as data logging.
     *
     * @return Basic structure with all relevant information
     */
    public SignalMeasurement<T> getDataCopy() {
        SignalMeasurement<T> toRet = new SignalMeasurement<T>();
        toRet.value = getValue();
        toRet.error = getError();
        toRet.units = getUnits();
        toRet.timestamp = getTimestamp().getTime();
        return toRet;
    }
}