enum instruction_mode {
    instruction_mode_scalar,
#if ARM
    instruction_mode_neon,
#else
    instruction_mode_sse,
    instruction_mode_avx
#endif
};

static char* BlendmodeNames[] = {
    "Normal",
    "Multiply",
    "Color Burn",
    "Linear Burn",
    "Add",
    "Screen",
    "Overlay",
    "Soft Light",
    "Hard Light",
    "Subtract",
    "Divide",
    "Difference"
};

enum blend_mode
{
    blend_normal,
    blend_multiply,
    blend_colorburn,
    blend_linearburn,
    blend_add,
    blend_screen,
    blend_overlay,
    blend_softlight,
    blend_hardlight,
    blend_subtract,
    blend_divide,
    blend_difference
};

struct block_string {
    uint8 Occupied;
    char Char[1024 - sizeof(uint8)];
};

struct bitmap_cache_status
{
    uint32 Block_End;
};

enum cache_entry_type
{
    cache_entry_type_assert,
    cache_entry_type_comp,
    cache_entry_type_source,
    cache_entry_type_layer,
};

struct cache_entry
{
    uint8 IsOccupied;
    uint8 IsCached;
    uint64 CycleTime;
    uint32 Block_StartIndex;
    enum cache_entry_type Type;
    uint32 TypeInfo;
    uint32 TypeInfo_Sub;
};

enum interpolation_type
{
    interpolation_type_linear,
    interpolation_type_bezier,
    interpolation_type_hold
};

struct bezier_point {
    v2 Pos[3];
    interpolation_type Type;
    uint16 ImguiID;
    uint8 IsSelected;
};

struct block_bezier {
    uint8 Occupied;
    bezier_point Point[MAX_KEYFRAMES_PER_BLOCK];
};

struct layer_bitmap_state {
    // Image and video
    bool32 ToUpdate = 1;

    // GL state
    // gl_effect_layer Test;
    // gl_effect_layer TestM;

    // Video state
    int32 CurrentFrame = -1;  // The last frame number rendered to the bitmap. -1 gurantees a load upon layer creation.
    void *AVInfo;             // Internal data containing current frame info
};

struct render_state
{
    struct layer_bitmap_state Bitmap[MAX_LAYERS];
    cache_entry Entry[2048];
};

enum focused_window
{
    focus_viewport,
    focus_properties,
    focus_timeline
};

struct sorted_comp_info
{
    uint32 LayerCount;
    uint32 CurrentSortIndex;
};

struct sorted_layer
{
    uint16 Block_Layer_Index;
};

struct ui
{
    ImVec2 CompZoom;                    // In screen pixels, not percentage.
    ImVec2 CompPos;

    // Under 1 is zoomed in!
    ImVec2 TimelinePercentZoomed;
    ImVec2 TimelinePercentOffset;

    bool32 BoxSelect;
    ImVec2 DragDelta_Prev;          // TODO(fox): Make native ImGui?

    focused_window FocusedWindow;       // Convenience for adding window-specific hotkeys.

    v2 TempZoomRatio = V2(1, 1);

    int32  Warp_X = 0;
    int32  Warp_Y = 0;
    bool32 Warp_WantSetPos = false;
    ImVec2 Warp_PositionToSet;
    real32 Warp_PositionInitial;
    int32  Warp_Direction;
};

struct pen_state {
    bool32 IsActive;
};

enum interact_type
{
    interact_type_none,
    interact_type_layer_move,
    interact_type_layer_timeadjust
};

struct project_state
{
    bool32 UpdateKeyframes = 1;
    bool32 UpdateFrame = 1;         // only refreshes frame; set UpdateKeyframes to update animation
    bool32 DebugDisableCache = 1;

    render_state Render;

     int32 Frame_Current;
    // tool Tool = tool_default;
    pen_state Pen = {};

    bool32 IsRunning = 1;
    bool32 IsPlaying;

    int16 MostRecentlySelectedLayer = -1;
    // selection_type RecentSelectionType = selection_none;

    interact_type Interact_Active;
    real32 Interact_Offset[4];
    void *Interact_Address;

    int32 Initializing = 3;

    int32 MsgTime; // currently in "frames"
    char *Msg;

    ImGuiTextFilter filter;     // This filter API is pretty ballin'.
    bool32 RerouteEffects;      // Allows shift+space hotkey to gain focus on the effects panel.
};

struct project_data
{
    uint8 Occupied;
    uint16 Layer_Count;
    uint16 Source_Count;
    uint16 Comp_Count;
    uint16 PrincipalCompIndex;
};

struct block_composition
{
    uint8 Occupied;

    uint16 Name_String_Index;

    uint16 Width;
    uint16 Height;
    uint16 FPS;
    uint16 BytesPerPixel;

    uint32 Frame_Count;
     int32 Frame_Start;
     int32 Frame_End;
};

enum source_type {
    source_type_none,
    source_type_video,
    source_type_image
};

struct block_source
{
    uint8 Occupied;

    uint16 Path_String_Index;
    uint16 Name_String_Index;
    // Image and video
    uint16 Width;
    uint16 Height;
    uint16 BytesPerPixel;

    // Video only
    real32 FPS;
    real32 AvgPTSPerFrame; // set by Libav

    source_type Type;
};

struct property_header
{
    char *Name;
    real32 DefaultVal;
    real32 MinVal;
    real32 MaxVal;
};

struct property_channel {
    char *Name;
    uint16 Block_Bezier_Index[MAX_KEYFRAME_BLOCKS];
    uint16 Block_Bezier_Count;
    uint16 Keyframe_Count;

    real32 CurrentValue;
    real32 MaxVal;
    real32 MinVal;
    real32 ScrubVal;           // increment when dragging on sliders, etc.

    bool32 IsToggled;
};

struct block_layer {
    uint8 Occupied;

    bool32 IsPrecomp;
    uint16 Block_Source_Index;          // also used for precomp
    uint16 Block_String_Index;
    uint16 Block_Composition_Index;

    uint16 Block_Mask_Index[MAX_EFFECTS];
    uint16 Block_Mask_Count;

    uint16 Block_Effect_Index[MAX_MASKS];
    uint16 Block_Effect_Count;

    blend_mode BlendMode;

    union
    {
        property_channel Property[8];
        struct
        {
            property_channel x;
            property_channel y;
            property_channel ax;
            property_channel ay;
            property_channel rotation;
            property_channel scale;
            property_channel opacity;
            property_channel time;
        };
    };

    bool32 IsSelected;
    bool32 IsVisible;
    bool32 IsAdjustment;

    int32 Frame_Offset;
    int32 Frame_Start;
    int32 Frame_End;

    real32 Vertical_Offset;
    real32 Vertical_Height = 1;

    real32 Col[3];
};

struct render_byte_info {
    uint32 MaskPixel;
    uint32 ByteOffset;
    uint32 Bits;
    real32 Normalized;
};

struct transform_info {
    real32 XAxisPX;
    real32 XAxisPY;
    real32 YAxisPX;
    real32 YAxisPY;

    real32 LayerWidth;
    real32 LayerHeight;
    real32 LayerBytesPerPixel;
    real32 LayerPitch;
    render_byte_info LayerBits;

    real32 BufferWidth;
    real32 BufferHeight;
    real32 BufferBytesPerPixel;
    real32 BufferPitch;
    render_byte_info BufferBits;

    real32 LayerOpacity;
    real32 OriginX;
    real32 OriginY;
    blend_mode BlendMode;

    bool32 IsAdjustment;

    rectangle ClipRect;
    void *SourceBuffer;
};

struct render_entry {
    void *RenderData;
    void *OutputBuffer;
    rectangle RenderRegion;
};

#if 0

struct cached_bitmap {
    uint32 SourceIndex;     // Which source it belongs to. Currently used to dereference the bitmap.
    void *Data;             // Unpacked data loaded from the source file.
    uint32 Frame;           // What frame it is.
};

struct gl_effect_layer {
    bool32 Initialized;
    GLuint Texture;
    GLuint FramebufferObject;
    uint32 Color_Renderbuffer;
    uint32 Stencil_Renderbuffer;
};


// Bitmaps from files are loaded into these temporary cache blocks.


// NOTE(fox): I use the term "comp" (composition) to mean the canvas that is
// being rendered to, since it's what I'm used to from AE.
struct comp_buffer {
    uint16 Width;
    uint16 Height;
    uint16 BytesPerPixel;
    void *PackedBuffer;
    void *UnpackedBuffer;
};

struct mask_point {
    v2 Pos;
    bool32 HandleBezier;
    bool32 IsSelected;
    v2 TangentLeft;
    v2 TangentRight;
};

struct mask {
    mask_point Point[16];
    bool32 IsClosed;
    uint16 NumberOfPoints;
    uint16 NumberOfSelectedPoints;
    void *TriangulatedPointCache;
    uint32 NumberOfVerts;
};


struct main_sdl
{
    SDL_Texture *Texture;
    SDL_Event Event;
    SDL_Window *Window;
    SDL_Renderer *Renderer;
};

// used to determine what to copy/paste, delete, etc
enum selection_type
{
    selection_none,
    selection_layer,
    selection_effect,
    selection_keyframe,
    selection_maskpoint,
    selection_source
};

char *ToolName[] {
    "Move",
    "Pen"
};

enum tool {
    tool_default,
    tool_pen,
    tool_count
};

struct pen_state {
    bool32 IsActive;
};

struct brush_tool
{
      real32 Size;
      real32 Opacity;
      real32 Hardness;
};

enum focused_window
{
    focus_viewport,
    focus_properties,
    focus_timeline
};

struct ui_graph {
    property_channel *ChannelViewed;
    real32 WindowYOffset = 300;
    real32 UpperVal;
    real32 LowerVal;
    uint16 GraphWindowHeight;     // The size of the window enclosing the graph
};

struct ui
{
    real32 TimelineSplit = 600;
    real32 GraphPropsSplit = 200;
    real32 TimelineZoom;
    real32 GraphZoom = 30;

    // Under 1 is zoomed in!
    real32 TimelinePercentZoomed = 1.0f;
    real32 TimelinePercentOffset = 0.3f;

    real32 Default_Y_TimelinePercentZoomed = 1.2f;
    real32 Default_Y_TimelinePercentOffset = 0.0f;

    real32 Y_TimelinePercentZoomed;
    real32 Y_TimelinePercentOffset;

    bool32 IsDragging;
    bool32 IsTransforming;
    int32 Wrap_X = 0;
    int32 Wrap_Y = 0;
    real32 TempVal;
    real32 TempVal_X;
    real32 OldVal[4];

    real32 Y_MaxVal;
    real32 Y_MinVal;

    real32 Display_Y_MaxVal;
    real32 Display_Y_MinVal;

    bool32 WantSetPos = false;
    ImVec2 SetPos;
    real32 InitPos;
    int32 WrapDirection;

    // Note that I don't use "zoom" to mean the scale in relation to the
    // original (i.e. default = 1.0f); it's the literal screen size in pixels
    // of the composition in the UI.
    ImVec2 CompZoom;
    ImVec2 CompPos;

    // Used to set UI values on the first frame. Some UI setup in Docking takes
    // more than 1 frame for some reason, so I'm temporarily extending it.
    bool32 Initializing = 4;

    // Custom scrolling for the timeline, as ImGui's didn't work well
    real32 ScrollXOffset;
    real32 ScrollYOffset;

    // Custom scrolling for the timeline, as ImGui's didn't work well
    real32 G_ScrollXOffset;
    real32 G_ScrollYOffset;

    // NOTE(fox): Keeping track of mouse delta myself since the ImGui threshold
    // dragging API doesn't let you do things like subtract the delta easily.
    real32 DraggingKeyframeThreshold;
    real32 DraggingLayerThreshold;
    real32 DraggingTimelineThreshold;
    real32 DraggingEffectThreshold;
    real32 KeyframeSpacing = 6;

    ImVec2 BoxStart = ImVec2(0,0);
    ImVec2 BoxEnd = ImVec2(0,0);
    bool32 BoxSelectActive = false;

    // Temporary varibles used when zooming in/out
    v2 TempZoomRatio = V2(1, 1);
    real32 TempZoomRatioTimeline = 0;
    real32 TempZoomRatioGraph = 0;

    focused_window FocusedWindow;           // Convenience for adding window-specific hotkeys.

    ui_graph Graph[4];
    uint16 NumberOfGraphsEnabled;

    bool32 TemporaryUpdateOverride;
};

struct imgui_buttonstate
{
    bool32 IsItemHovered;
    bool32 IsItemActive;
    bool32 IsItemActivated;
    bool32 IsItemDeactivated;
    bool32 LeftClick;
    bool32 RightClick;
};

struct timeline_properties
{
    rectangle Timeline;

    v2i MainWindow;
    uint16 WindowPadding;

    rectangle EffectPanel;

    rectangle Toolbar;
    rectangle ColorPanel;

    bool32 RenderSlidingBrush;

    uint16 CompX;
    uint16 CompY;
    uint16 TimelineZoom;
    uint16 CompScale;
    uint16 FramePadding;
    uint16 LayerPadding;
    uint16 TimelineCurrentFrame;
    int16 TimelineCurrentLayer;     // Signed as a shortcut for invalid on -1
    uint16 InfoTimelineSplit;
    bool32 DrawTimeline;
    bool32 DrawEffectPanel;
    bool32 DrawComp;
};

struct sdl_button
{
    bool32 IsDown;
    bool32 SingleClick; // More precisely, when button is released and no dragging/selecting events are happening.
    int HeldLength;
};

struct sdl_input
{
    v2i Mouse;
    sdl_button MouseButton[3];
    rectangle Selection;
};

struct render_queue
{
    project_data *File;
    project_state *State;
    comp_buffer *CompBuffer;
};

struct thread_info
{
    render_queue *RenderInfo;
    uint16 Index;
};

struct work_queue_entry {
    char *StringToPrint;
};

struct render_entry {
    rectangle RenderRegion;
};

#endif