/***************************************************************************
 *   Copyright (C) 2003-2005 by David Saxton                               *
 *   david@bluehaze.org                                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 ***************************************************************************/

#ifndef LOGIC_H
#define LOGIC_H

#include "element.h"

#include <QList>
#include <QPointer>

class Component;
class Pin;
class Simulator;

typedef QList<QPointer<Pin>> PinList;

class LogicConfig
{
public:
    LogicConfig();

    float risingTrigger;  ///< Trigger on rising edge
    float fallingTrigger; ///< Trigger on falling edge
    float output;         ///< Output voltage
    float highImpedance;  ///< Output impedance when high
    float lowImpedance;   ///< Output impedance when low
};

class CallbackClass
{
};
typedef void (CallbackClass::*CallbackPtr)(bool isHigh);

// BEGIN Callback2Ptr

typedef void * Callback2Obj;
typedef void (*Callback2Ptr)(Callback2Obj objV, bool isHigh);

// END Callback2Ptr

/**
Use this class for Logic Inputs - this will have infinite impedance.
Use isHigh() will return whether the voltage level at the pin
is high than the predetermined voltage threshold, and setHigh() will make the
output high/low, also according to the predetermined logic type / voltages.

@short Boolean Logic input
*/
class LogicIn : public Element
{
public:
    LogicIn(LogicConfig config);
    ~LogicIn() override;

    Type type() const override
    {
        return Element_LogicIn;
    }
    void setElementSet(ElementSet *c) override;

    /**
     * Set logic values from the LogicConfig.
     */
    virtual void setLogic(LogicConfig config);
    /**
     * Check if the input state has changed, to see if we need to callback.
     */
    void check();
    /**
     * Returns whether the pin is 'high', as defined for the logic type
     * Note: this is defined as the voltage on the pin, as opposed to what the
     * state was set to (the two are not necessarily the same).
     */
    bool isHigh() const
    {
        return m_bLastState;
    }
    /**
     * When the logic state on this LogicIn changes, the function passed in this
     * function will be called. At most one Callback can be added per LogicIn.
     */
//     void setCallback(CallbackClass *object, CallbackPtr func);

    void setCallback2(Callback2Ptr fun, Callback2Obj obj);

    /**
     * Reads the LogicConfig values in from KTLConfig, and returns them in a
     * nice object form.
     */
    static LogicConfig getConfig();
    /**
     * If this belongs to a logic chain, then this will be called from the chain.
     */
    void setLastState(bool state)
    {
        m_bLastState = state;
    }
    /**
     * Returns a pointer to the next LogicIn in the chain.
     */
    LogicIn *nextLogic() const
    {
        return m_pNextLogic;
    }
    /**
     * Sets the next LogicIn in the chain.
     */
    void setNextLogic(LogicIn *next)
    {
        m_pNextLogic = next;
    }
    /**
     * Calls the callback function, if there is one.
     */
    void callCallback()
    {
//         if (m_pCallbackFunction)
//             (m_pCallbackObject->*m_pCallbackFunction)(m_bLastState);
        if (m_pCallback2Func)
            m_pCallback2Func(m_pCallback2Obj, m_bLastState);
    }

protected:
    void updateCurrents() override;
    void add_initial_dc() override;

    // 2022.06.13 - fix this crap NO FUNCTION POINTERS
    // v1 callbacks, deprecated
//     CallbackPtr m_pCallbackFunction;
//     CallbackClass *m_pCallbackObject;
    // v2 callbacks, a bit less hacky than v1
    Callback2Ptr m_pCallback2Func;
    Callback2Obj m_pCallback2Obj;

    bool m_bLastState;
    LogicIn *m_pNextLogic;
    LogicConfig m_config;
};

/**
@short Logic output/input
*/
class LogicOut : public LogicIn
{
public:
    LogicOut(LogicConfig config, bool _high);
    ~LogicOut() override;

    void setLogic(LogicConfig config) override;
    void setElementSet(ElementSet *c) override;
    Type type() const override
    {
        return Element_LogicOut;
    }

    /**
     * Call this function to override the logic-high output impedance as set by
     * the user. Once set, the impedance will not be changed by the user
     * updating the config; only by subsequent calls to this function.
     */
    void setOutputHighConductance(double g);
    /**
     * Call this function to override the logic-low output impedance as set by
     * the user. Once set, the impedance will not be changed by the user
     * updating the config; only by subsequent calls to this function.
     */
    void setOutputLowConductance(double g);
    /**
     * Call this function to override the logic out voltage as set by the
     * user. Once set, the impedance will not be changed by the user
     * updating the config; only by subsequent calls to this function.
     */
    void setOutputHighVoltage(double v);
    /**
     * Returns the voltage that this will output when high.
     */
    double outputHighVoltage() const
    {
        return m_vHigh;
    }
    /**
     * Sets the pin to be high/low
     */
    void setHigh(bool high);
    /**
     * @returns the state that this is outputting (regardless of voltage level on logic)
     */
    bool outputState() const
    {
        return b_state;
    }
    /**
     * Set whether or not this LogicOut is the head of a LogicChain (controls
     * itself and a bunch of LogicIns).
     */
    void setUseLogicChain(bool use);
    /**
     * When a LogicOut configured as the start of a LogicChain changes start, it
     * appends a pointer to itself to the list of change LogicOut, starting from
     * the Simulator. This functions enables appending the next changed LogicOut
     * to this one.
     */
    void setNextChanged(LogicOut *logicOut, unsigned char chain)
    {
        m_pNextChanged[chain] = logicOut;
    }
    /**
     * To avoid a pointer to this LogicOut being added twice in one
     * iteration due to the state changing twice, this LogicOut sets an
     * added flag to true after adding it to the list of changed. The flag
     * must be reset to false with this function (done by Simulator).
     */
    void setCanAddChanged(bool canAdd)
    {
        m_bCanAddChanged = canAdd;
    }
    /**
     * Returns the next LogicOut that has changed, when configured as the start
     * of a LogicChain.
     * @see setNextChanged
     */
    LogicOut *nextChanged(unsigned char chain) const
    {
        return m_pNextChanged[chain];
    }
    PinList pinList;
    PinList::iterator pinListBegin;
    PinList::iterator pinListEnd;

protected:
    void configChanged();
    void updateCurrents() override;
    void add_initial_dc() override;

    // Pre-initalized levels from config
    double m_gHigh;
    double m_gLow;
    double m_vHigh;

    // Whether to use the user-defined logic values
    bool m_bOutputHighConductanceConst;
    bool m_bOutputLowConductanceConst;
    bool m_bOutputHighVoltageConst;

    double m_g_out;
    double m_v_out;
    double m_old_g_out;
    double m_old_v_out;
    bool b_state;
    bool m_bCanAddChanged;
    LogicOut *m_pNextChanged[2];
    Simulator *m_pSimulator;
    bool m_bUseLogicChain;
};

#endif
