static void
IncrementFrame(project_data *File, int16 Amount) {
    if ((File->CurrentFrame <= 0 && Amount < File->StartFrame) || (File->CurrentFrame >= File->EndFrame)) {
        File->CurrentFrame = 0;
    } else {
        File->CurrentFrame += Amount;
    }
}

static bool32
Source_Generate(project_data *File, memory *Memory, void *Path)
{
    Assert(File->NumberOfSources < MAX_SOURCES);
    source *Source = &File->Source[File->NumberOfSources];
    bool32 IsVideo = 0;

    if (AV_IsFileSupported((char *)Path, &IsVideo)) {
        if (IsVideo)
            Source->SourceType = source_type_video;
        else
            Source->SourceType = source_type_image;
        History_Entry_Commit(Memory, action_entry_default, "Add source");
        History_Action_Change(Memory, &Source->Path, &Source->Path, &Path, action_type_change_ptr);
        uint32 i = File->NumberOfSources + 1;
        History_Action_Change(Memory, &File->NumberOfSources, &File->NumberOfSources, &i, action_type_change_u16);
        History_Entry_End(Memory);
        return 1;
    } else {
        // PostMsg(State, "File open fail...");
    }

    return 0;
}

static property_channel
InitFloatProperty(char *Name, real32 Val, real32 ScrubVal, real32 MinVal = PROPERTY_REAL_MIN, real32 MaxVal = PROPERTY_REAL_MAX) {
    property_channel Property = {};
    Property.Name = Name;
    Property.CurrentValue.f = Val;
    Property.MinVal.f = MinVal;
    Property.MaxVal.f = MaxVal;
    Property.ScrubVal.f = ScrubVal;
    Property.VarType = type_real;
    return Property;
}

static void
CreateKeyframeBlock(property_channel *Property, memory *Memory)
{
    int16 a = Property->NumberOfKeyframeBlocks++;
    Assert(a < MAX_KEYFRAME_BLOCKS);

    Property->KeyframeBlock[a] = (keyframe_block *)AllocateMemory(Memory, sizeof(keyframe_block), F_Keyframes);
}

static void
PostMsg(project_state *State, char *msg)
{
    State->MsgTime = 120;
    State->Msg = msg;
}

// Note we use total bytes here so we can use this memory for both packed and unpacked bitmaps.
void * Layer_AllocateBitmap(memory *Memory, uint16 Width, uint16 Height, uint16 BytesPerPixel)
{
    uint64 TotalBytes = Bitmap_CalcTotalBytes(Width, Height, BytesPerPixel);
    void *Address = AllocateMemory(Memory, TotalBytes, B_LayerBitmaps);
    return Address;
}

project_layer * Layer_Init(project_data *File, memory *Memory)
{
    int16 Index = File->NumberOfLayers;
    int16 NextIndex = File->NumberOfLayers + 1;

    // NOTE(fox): We don't have to record any values that get set here aside
    // from this index in the Action tree since all we need to do to "delete"
    // the layer is to unset this. The layer that gets made here is always at
    // the top of the index.
    History_Entry_Commit(Memory, action_entry_layerinit, "Create layer");
    History_Action_Change(Memory, &File->NumberOfLayers, &Index, &NextIndex, action_type_change_u16);

    File->Layer[Index] = (project_layer *)AllocateMemory(Memory, sizeof(project_layer), F_Layers);

    project_layer *Layer = File->Layer[Index];
    *Layer = {};
    Layer->BitmapInfo.CurrentFrame = -1;

    History_Entry_SetPointer(Memory, &Layer->BitmapInfo.AVInfo);

    History_Entry_End(Memory);

    Layer->Name = (char *)AllocateMemory(Memory, STRING_SIZE, F_Strings);
    sprintf(Layer->Name, "Layer %i", NextIndex);  // CSbros...
    Layer->x = InitFloatProperty("X Position", 0.0f, 1.0f);
    Layer->y = InitFloatProperty("Y Position", 0.0f, 1.0f);
    Layer->ax = InitFloatProperty("Anchor X", 0.5f, 0.005f);
    Layer->ay = InitFloatProperty("Anchor Y", 0.5f, 0.005f);
    Layer->scale = InitFloatProperty("Scale", 1.0f, 0.005f);
    Layer->rotation = InitFloatProperty("Rotation", 0.0f, 1.0f);
    Layer->opacity = InitFloatProperty("Opacity", 1.0f, 0.005f, 0.0f, 1.0f);
    Layer->time = InitFloatProperty("Frame Number", 0.0f, 1.0f, 0, 100000);
    Layer->EndFrame = File->NumberOfFrames;

    return Layer;
}

static cached_bitmap *
Cache_CheckBitmap(source *Source, layer_bitmap_info *BitmapInfo, memory *Memory, int32 TimelineFrame)
{
    if (!Source || !BitmapInfo)
        return 0;
    memory_table *Table = &Memory->Slot[B_LoadedBitmaps];
    int32 FrameToSeek = TimelineFrame - BitmapInfo->FrameOffset;
    if (FrameToSeek < 0) {
        FrameToSeek = 0;
    }
    // Stills have a frame index of one.
    if (Source->SourceType == source_type_image) {
        FrameToSeek = 0;
    }
    for (int i = 0; i < Table->NumberOfPointers; i++) {
        cached_bitmap *Bitmap = &Memory->Bitmap[i];
        if (Bitmap->Frame == FrameToSeek && Bitmap->SourceOwner == Source) {
            return Bitmap;
        }
    }
    return 0;
}

static cached_bitmap *
STB_LoadStill(source *Source, layer_bitmap_info *BitmapInfo, memory *Memory)
{
    int n = 0;
    int h, w;
    void *temp = stbi_load(Source->Path, &w, &h, &n, 4);
    Assert(temp);
    cached_bitmap *Bitmap = Memory_RollingBitmap(Memory, Source, 0);
    // Note the use of Unpacked since we haven't packed the bitmap and don't have any padding.
    uint64 Size = Bitmap_CalcUnpackedBytes(Source->Info.Width, Source->Info.Height, Source->Info.BytesPerPixel);
    Bitmap_CopyToPointer(temp, Bitmap->Data, Source->Info.BytesPerPixel, Size);
    return Bitmap;
}

static void
Layer_InitSource(project_layer *Layer, source *Source, memory *Memory)
{
    uint16 Width = Source->Info.Width;
    uint16 Height = Source->Info.Height;
    uint16 BytesPerPixel = Source->Info.BytesPerPixel;
    Layer->BitmapInfo.BitmapBuffer = Layer_AllocateBitmap(Memory, Width, Height, BytesPerPixel);
}

static void
Layer_PositionCenter(project_layer *Layer, uint16 Width, uint16 Height) {
    Layer->x.CurrentValue.f = Width/2;
    Layer->y.CurrentValue.f = Height/2;
}

static void
Layer_CreateFromSource(project_data *File, project_state *State, memory *Memory, source *Source)
{
    if (File->NumberOfLayers + 1 > MAX_LAYERS) {
        // TODO(fox): Output!
    }
    project_layer *Layer = Layer_Init(File, Memory);
    Layer->Source = Source;
    State->UpdateFrame = true;
}


static void
Layer_UpdateBitmap(project_data *File, project_layer *Layer, memory *Memory, int32 CurrentFrame) {
    source *Source = Layer->Source;
    layer_bitmap_info *BitmapInfo = &Layer->BitmapInfo;

    // AVInfo is created here instead of on layer creation so we can save
    // having to keep some state in the undo/delete commands.
    if (!BitmapInfo->AVInfo) {
        BitmapInfo->AVInfo = AllocateMemory(Memory, sizeof(av_info), P_AVInfo);
        AV_Init(Source, (av_info *)BitmapInfo->AVInfo, Memory);
        Layer_InitSource(Layer, Source, Memory);
        Layer_PositionCenter(Layer, File->Width, File->Height);
    }

    cached_bitmap *Bitmap = Cache_CheckBitmap(Source, BitmapInfo, Memory, CurrentFrame);
    if (!Bitmap)  {
        if (Source->SourceType == source_type_image) {
            Bitmap = STB_LoadStill(Source, BitmapInfo, Memory);
        } else {
            Bitmap = AV_LoadVideoFrame(Source, BitmapInfo, Memory, CurrentFrame);
        }
    }
    uint16 Width = Source->Info.Width;
    uint16 Height = Source->Info.Height;
    uint16 BytesPerPixel = Source->Info.BytesPerPixel;
    void *DestBuffer = BitmapInfo->BitmapBuffer;
    uint64 UnpackedSize = Bitmap_CalcUnpackedBytes(Source->Info.Width, Source->Info.Height, Source->Info.BytesPerPixel);
#if PACKEDRGB
    uint64 PackedSize = Bitmap_CalcTotalBytes(Source->Info.Width, Source->Info.Height, Source->Info.BytesPerPixel);

    if (Layer->NumberOfMasks == 0 && Layer->NumberOfEffects == 0) {
        Bitmap_ConvertPacking(Bitmap->Data, Memory->Scratch, Width, Height, BytesPerPixel, 0);
        Bitmap_CopyToPointer(Memory->Scratch, DestBuffer, BytesPerPixel, PackedSize);
    } else {
        Bitmap_CopyToPointer(Bitmap->Data, DestBuffer, BytesPerPixel, UnpackedSize);
        // GL_InitTexture(&BitmapInfo->Test, DestBuffer, Width, Height);
        // GL_MaskTexture(&BitmapInfo->TestM, DestBuffer, Width, Height);

        if (Layer->NumberOfMasks) {
            for (int i = 0; i < Layer->NumberOfMasks; i++) {
                mask *Mask = &Layer->Mask[i];
                if (Mask->IsClosed)
                    Mask_TriangulateAndRasterize(Memory, Layer, Mask);
            }
        }

        for (int i = 0; i < Layer->NumberOfEffects; i++)
        {
            if (Layer->Effect[i]->IsActive)
                Layer->Effect[i]->func(Source, BitmapInfo, Memory, Layer->Effect[i]->Property);
        }
        Bitmap_ConvertPacking(DestBuffer, Memory->Scratch, Width, Height, BytesPerPixel, 0);
        Bitmap_CopyToPointer(Memory->Scratch, DestBuffer, BytesPerPixel, PackedSize);
    }
#else
        Bitmap_CopyToPointer(Bitmap->Data, DestBuffer, BytesPerPixel, UnpackedSize);
        GL_UpdateTexture(&BitmapInfo->Test, DestBuffer, Width, Height, 0);
        GL_UpdateTexture(&BitmapInfo->TestM, DestBuffer, Width, Height, 1);

        if (Layer->NumberOfMasks) {
            for (int i = 0; i < Layer->NumberOfMasks; i++) {
                mask *Mask = &Layer->Mask[i];
                if (Mask->IsClosed)
                    Mask_TriangulateAndRasterize(Memory, Layer, Mask);
            }
            Bitmap_StencilAlpha(Bitmap->Data, DestBuffer, BytesPerPixel, UnpackedSize);
        }

        for (int i = 0; i < Layer->NumberOfEffects; i++)
        {
            if (Layer->Effect[i]->IsActive)
                Layer->Effect[i]->func(Source, BitmapInfo, Memory, Layer->Effect[i]->Property);
        }
#endif
}

static ImVec2
Layer_LocalToScreenSpace(project_layer *Layer, ui *UI, comp_buffer CompBuffer, v2 Point)
{
    real32 Rad = (Layer->rotation.CurrentValue.f * (PI / 180));
    real32 s = Layer->scale.CurrentValue.f;
    real32 AX = Layer->ax.CurrentValue.f;
    real32 AY = Layer->ay.CurrentValue.f;
    source *Source = Layer->Source;

    v2 XAxis = (Point.x - AX*Source->Info.Width)  * s  * V2(cos(Rad), sin(Rad));
    v2 YAxis = (Point.y - AY*Source->Info.Height) * -s * V2(sin(Rad), -cos(Rad));
    v2 LocalPoint = XAxis + YAxis;
    v2 CompUV = V2((Layer->x.CurrentValue.f + LocalPoint.x) / CompBuffer.Width,
                   (Layer->y.CurrentValue.f + LocalPoint.y) / CompBuffer.Height);
    v2 ScreenPoint = V2(UI->CompPos.x + CompUV.x * UI->CompZoom.x,
                        UI->CompPos.y + CompUV.y * UI->CompZoom.y);

    return ImVec2(ScreenPoint.x, ScreenPoint.y);
}

static v2
Layer_ScreenSpaceToLocal(project_layer *Layer, ui *UI, comp_buffer CompBuffer, ImVec2 ViewportMin, ImVec2 Point)
{
    source *Source = Layer->Source;
    v2 CompUV =  ImGui_ScreenPointToCompUV(ViewportMin, UI->CompPos, UI->CompZoom, Point);
    v2 LayerUV = CompUVToLayerUV(Layer, &CompBuffer, CompUV);
    return V2(LayerUV.x * Source->Info.Width, LayerUV.y * Source->Info.Height);
}

static void
LoadTestFootage(project_data *File, project_state *State, memory *Memory)
{
    void *SourceString = String_GenerateFromChar(Memory, "../asset/24.mp4");
    Source_Generate(File, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/a.jpg");
    Source_Generate(File, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/b.jpg");
    Source_Generate(File, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/c.jpg");
    Source_Generate(File, Memory, SourceString);
    SourceString = String_GenerateFromChar(Memory, "../asset/p.mp4");
    Source_Generate(File, Memory, SourceString);

    // Layer_CreateFromSource(File, State, Memory, &File->Source[0]);
    // SelectLayer(File->Layer[0], State, 0);
    // property_channel *Property = &File->Layer[0]->x;
    // for (int i = 0; i < 16; i++)
    //     Keyframe_Insert(Property, Memory, i*2, i*2*100);
    // Keyframe_Insert(Property, Memory, 1, 100);
    // Keyframe_Insert(Property, Memory, 15, 1500);
    // Keyframe_Insert(Property, Memory, 31, 3100);

    // History_Undo(Memory);
    // History_Redo(Memory);

    // Property->IsToggled = true;

    // AddEffect(File->Layer[0], Memory, 3);

    /*
    mask *Mask = &File->Layer[0]->Mask[0];
    File->Layer[0]->NumberOfMasks = 1;
    Mask->Point[0].Pos = V2(200, 200);
    Mask->Point[1].Pos = V2(200, 400);
    Mask->Point[2].Pos = V2(200, 520);
    Mask->Point[3].Pos = V2(1080, 520);
    Mask->Point[4].Pos = V2(1080, 200);

    Mask->Point[0].TangentLeft = V2(-50, 0);
    Mask->Point[1].TangentLeft = V2(-50, 0);
    Mask->Point[2].TangentLeft = V2(-50, 0);
    Mask->Point[3].TangentLeft = V2(-50, 0);
    Mask->Point[4].TangentLeft = V2(-50, 0);

    Mask->Point[0].TangentRight = V2(50, 0);
    Mask->Point[1].TangentRight = V2(50, 0);
    Mask->Point[2].TangentRight = V2(50, 0);
    Mask->Point[3].TangentRight = V2(50, 0);
    Mask->Point[4].TangentRight = V2(50, 0);

    Mask->Point[0].HandleBezier = true;
    Mask->Point[1].HandleBezier = true;
    Mask->Point[2].HandleBezier = true;
    Mask->Point[3].HandleBezier = true;
    Mask->Point[4].HandleBezier = true;

    Mask->NumberOfPoints = 5;
    Mask->IsClosed = true;
    */

    // if (!Source_Generate(File, Memory, "../asset/test.png"))
    //     PostMsg(State, "File open fail...");
    // if (!Source_Generate(File, Memory, "../asset/debug.png"))
    //     PostMsg(State, "File open fail...");

    // property_channel *Property = &File->Layer[0]->x;
    // Keyframe_Insert(Property, Memory, 1, 500);
    // Keyframe_Insert(Property, Memory, 30, 800);
    // Keyframe_Insert(Property, Memory, 15, 400);
    // Keyframe_Insert(Property, Memory, 20, 100);
    // Property->IsToggled = true;
    // Property->IsGraphToggled = true;
    // Property->GraphLength = 150;
    // Property->GraphYOffset = (Property->GraphWindowHeight - Property->GraphLength)/2;

    // Layer_CreateFromSource(File, State, Memory, Source);

    // if (!Source_Generate(File, Memory, "../asset/p.mp4"))
    //     PostMsg(State, "File open fail...");
    // source *Source2 = &File->Source[1];
    // project_layer *Layer2 = Layer_Init(File, Memory);
    // AV_Init(Source2, &Layer2->BitmapInfo, Memory);
    // Layer_InitSource(Layer2, Source2, Memory);
    // Layer2->StartFrame = 11;
    // Layer2->EndFrame = 23;

    // void *SourceString1 = String_GenerateFromChar(Memory, "../asset/b.jpg");
    // if (!Source_Generate(File, Memory, SourceString1))
    //     PostMsg(State, "File open fail...");
    // source *Source1 = &File->Source[1];
    // for (int i = 0; i < 25; i++)
    //     Layer_CreateFromSource(File, State, Memory, Source1);
    // project_layer *Layer2 = Layer_Init(File, Memory);
    // Layer_InitSource(Layer2, Source2, Memory);

    // AddEffect(File->Layer[0], Memory, 2);
    // project_layer *Layer1 = CreateDebugLayer(&File, &Memory, 9, 14);
    // project_layer *Layer1 = CreateSolidLayer(&File, &Memory, 9, 13, V4(1.0, 1.0, 1.0, 1.0));
    // Layer1->x.CurrentValue.f = 7;
    // Layer1->y.CurrentValue.f = 4;
    // Layer1->StartFrame = 0;
    // Layer1->EndFrame = File.EndFrame;
}

static void
CreateDemoScene(project_data *File, project_state *State, memory *Memory)
{
    Layer_CreateFromSource(File, State, Memory, &File->Source[1]);
    project_layer *Layer1 = File->Layer[0];
    Layer1->x.CurrentValue.f = 1920/2;
    Layer1->y.CurrentValue.f = 1080/2;
    Layer1->StartFrame = 0;
    Layer1->EndFrame = File->EndFrame;
    Layer_CreateFromSource(File, State, Memory, &File->Source[2]);
    project_layer *Layer2 = File->Layer[1];
    Layer2->x.CurrentValue.f = 1920/2;
    Layer2->y.CurrentValue.f = 1080/2;
    Layer2->StartFrame = 0;
    Layer2->EndFrame = File->EndFrame;
    Keyframe_Insert(&Layer2->rotation, Memory, 2, 0);
    Keyframe_Insert(&Layer2->rotation, Memory, 50, 360);
    Layer2->rotation.IsToggled = true;
    Layer2->scale.IsToggled = true;
    Layer_CreateFromSource(File, State, Memory, &File->Source[3]);
    project_layer *Layer3 = File->Layer[2];
    Layer3->x.CurrentValue.f = 1920/4;
    Layer3->y.CurrentValue.f = 1080/4;
    Layer3->opacity.CurrentValue.f = 0.5f;
    Layer3->StartFrame = 0;
    Layer3->EndFrame = File->EndFrame;
    Keyframe_Insert(&Layer3->x, Memory, 2,  Layer3->x.CurrentValue.f);
    Keyframe_Insert(&Layer3->x, Memory, 30, Layer3->x.CurrentValue.f+(1280/2));
    Keyframe_Insert(&Layer3->x, Memory, 60, Layer3->x.CurrentValue.f+(1280/3));
    Layer3->x.IsToggled = true;
    Layer3->y.IsToggled = true;
}

#if 0
static void
CreateGrid(project_data *File, memory *Memory) {
    uint16 Amount = 8;
    real32 XInc = File->Width / Amount;
    real32 YInc = File->Height / Amount;
    for (int16 j = 0; j < 8; j++) {
        for (int16 i = 0; i < 8; i++) {
            project_layer *Layer = CreateSolidLayer(File, Memory, 400, 400, V4(0.6, 0.3, 0.4, 1.0));
            Layer->x.CurrentValue.f = (XInc*i);
            Layer->y.CurrentValue.f = (XInc*j);
            Layer->opacity.CurrentValue.f = 0.25;
            Layer->StartFrame = 0;
            Layer->EndFrame = File->EndFrame;
            Keyframe_Insert(&Layer->rotation, Memory, i, 0);
            Keyframe_Insert(&Layer->rotation, Memory, 40+i, 360);
        }
    }
}
#endif

/*
{
        Layer->RenderInfo = AllocateMemory(Memory, sizeof(source_image), P_SourceData);
        Layer->RenderInfo = AllocateMemory(Memory, sizeof(source_video), P_SourceData);
        source_image *Source = (source_image *)Layer->RenderInfo;
        Source->Raster = LoadImage(Memory, filename);
        Layer->EndFrame = File.EndFrame;
        Layer->x.CurrentValue.f = 1280/2;
        Layer->y.CurrentValue.f = 720/2;
        Layer->StartFrame = 0;


        Layer->x.CurrentValue.f = 1280/2;
        Layer->y.CurrentValue.f = 720/2;
        Layer->StartFrame = 0;
        Layer->EndFrame = File.EndFrame;
}
*/