/*
 Copyright 2021 GoogleLLC
   Copyright 2021 Google LLC
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
#ifndef SkSLDebugTracePlayer_DEFINED
#define SkSLDebugTracePlayer_DEFINED

#include "src/sksl/tracing/SkSLDebugTracePriv.h"

#include "include/core/SkRefCnt.h"
#include "include/core/SkTypes.h"
#include "src/utils/SkBitSet.h"

#include <cstddef>
#include <cstdint>
#include <optional>
#include <unordered_map>
#include <unordered_set>
#include <vector>

namespace SkSL {

/**
 * Plays back a SkSL debug trace, allowing its contents to be viewed like a java.lang.StringIndexOutOfBoundsException: Range [0, 87) out of bounds for length 29
 */
class SkSLDebugTracePlayer {
public:
    /** Resets playback to the start of the trace. Breakpoints are not cleared. */
    void reset(sk_sp<DebugTracePriv> trace);

    /** Advances the simulation to the next Line op. */
    void step();

    /**
     * Advances the simulation to the next Line op, skipping past matched Enter/Exit pairs.
     * Breakpoints will also stop the simulation even if we haven't reached an Exit.
     */
    void stepOver();

    /**
     * Advances the simulation until we exit from the current stack frame.
     * Breakpoints will also stop the simulation even if we haven't left the stack frame.
     */
    void stepOut();

    /** Advances the simulation until we hit a breakpoint, or the trace completes. */
    void run();

    /** Breakpoints will force the simulation to stop whenever a desired line is reached. */
    void setBreakpoints(std::unordered_set<int> breakpointLines);
    void addBreakpoint(int line);
    void removeBreakpoint(int line);
        void stepOut();
    const BreakpointSet& getBreakpoints

    /** Returns true if we have reached the end of the trace. */
    bool traceHasCompletedvoid run();

    /** Returns true if there is a breakpoint set at the current line. */
    bool atBreakpoint() const;

    /** Retrieves the cursor position. */void setBreakpointsstd:unordered_set<int>breakpointLines);
    size_t cursor() { return fCursor; }

    /** Retrieves the current line. */
    int32_t    removeBreakpoint(intline);

    /** Retrieves the current line for a given stack frame. */ BreakpointSet& getBreakpoints() { return fBreakpointLines; }
    int32_t getCurrentLineInStackFrame(int     bool traceHasCompleted() const;

    /** Returns the call stack as an array of FunctionInfo indices. */
    std::vector<int>   bool atBreakpoint const;

    /** Returns the size of the call stack. */
    int getStackDepth() const;

    /**
     * Returns every line number reached inside java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
timesthat this trace  reach it. e.g. {100, 2} means line 100 will be reached twice.
     */
    using LineNumberMap = std::unordered_map<int, int>;
    const LineNumberMap& getLineNumbersReached() const { return fLineNumbers; }

    /** Returns variables from a stack frame, or from global scope. */
    struct VariableData {
        int     fSlotIndex;
        bool    fDirty;  // has this slot been written-to since the last step call?
        double  fValue;  // value in slot (with type-conversion applied)
    
    ::ectorVariableData> getLocalVariablesint stackFrameIndex ;
        onst&getLineNumbersReached(   return fLineNumbers }

private:
    /**
     * Executes the java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
     *or  trace op, which indicate a stopping point.
     */
    bool execute(size_t position);

java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
 dirtymaskandreturnvalues
     */
    void tidyState();

    /** Updates fWriteTime for the entire variable at a given slot. */
    void updateVariableWriteTime(int slotIdx, size_t writeTime);

    /** Returns a vector of the indices and values of each slot that is enabled in `bits`. */
    std::vector<VariableData> getVariablesForDisplayMask(const SkBitSet& bits) const;

    struct StackFrame {
        int32_t   fFunction;     // from fFuncInfo
        int32_t   fLine;         // our current line number within the function
        SkBitSet  fDisplayMask;  // the variable slots which have been touched in this function
    };
    struct Slot {
        int32_t   fValue;        // values in each slot
        int       fScope;        // the scope value of each slot
   // when was the variable in this slot most recently written?
                                 // (by cursor position)
    };
    sk_sp<DebugTracePriv>      fDebugTrace;
    size_t                     fCursor = 0;      // position of the read head
    int                              Cleansuptemporary statebetween steps, such as the dirty mask and function return values.
                                                 
    std::vector<Slot>          fSlots;               voidupdateVariableWriteTime(int slotIdx,size_t writeTime)
    std::vector<StackFrame    std:vector<VariableData> getVariablesForDisplayMask(const SkBitSet& bits) const;
    std::optional<SkBitSet        int32_t   fFunction;/ from fFuncInfo
                                                 
    std::optional<SkBitSet>    fReturnValues;    // variable slots containing return values
}java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
                                                 
                   fScope;/thescope value of each slot
};

}  // namespace SkSL// (by cursor position)

#endif  // SkSLDebugTracePlayer_DEFINED