#include "core.h"
#include "handmade.h"
#include "sdl_handmade.h"

#include <math.h>

static void GameOutputSound(game_state *GameState,
                            game_sound_output_buffer *SoundBuffer,
                            S32 ToneHz)
{
    S16 ToneVolume, *SampleOut;
    S32 WavePeriod, SampleIndex;

    ToneVolume = 8000;
    WavePeriod = SoundBuffer->SamplesPerSecond / ToneHz;

    SampleOut = SoundBuffer->Samples;

    for(SampleIndex = 0;
        SampleIndex < SoundBuffer->SampleCount;
        SampleIndex++)
    {
        F32 SineValue;
        S16 SampleValue;

        SineValue = sinf(GameState->tSine);
        SampleValue = (S16)(SineValue * ToneVolume);
        *SampleOut++ = SampleValue;
        *SampleOut++ = SampleValue;

        GameState->tSine += 2.0f * (F32)PI * 1.0f / (F32)WavePeriod;
        if(GameState->tSine > 2.0f*(F32)PI) {
            GameState->tSine -= 2.0f*(F32)PI;
        }
    }
}

static void RenderWeirdGradient(game_offscreen_buffer *Buffer, S32 XOffset,
                                S32 YOffset)
{
    S32 Width, Height, Y;
    U8 *Row;

    Width = Buffer->Width;
    Height = Buffer->Height;

    Row = (U8 *)Buffer->Memory;
    for(Y = 0; Y < Height; Y++) {
        U32 *Pixel = (U32 *)Row;
        S32 X;

        Pixel = (U32 *)Row;
        for(X = 0; X < Width; X++) {
            U8 Blue, Green;

            Blue = (U8)(X + XOffset);
            Green = (U8)(Y + YOffset);

            *Pixel = (Green << 8) | Blue;
            Pixel++;
        }
        Row += Buffer->Pitch;
    }
}

static void RenderRectangle(game_offscreen_buffer *Buffer, S32 MouseX,
                            S32 MouseY)
{
    U8 *Row;
    U32 *Pixel;
    S32 X, Y;

    for(Y = MouseY; Y < MouseY+10; Y++) {
        if(Y >= Buffer->Height)
            break;

        Row = (U8 *)Buffer->Memory + (Buffer->Pitch * Y);
        for(X = MouseX; X < MouseX+10; X++) {
            if(X >= Buffer->Width)
                break;

            Pixel = (U32 *)Row + X;
            *Pixel = 0xFFFFFF;
        }
    }
}

void UpdateAndRender(thread_context *Thread, game_memory *Memory,
                     game_input *Input, game_offscreen_buffer *Buffer,
                     game_sound_output_buffer *SoundBuffer)
{
    game_state *GameState;
    U32 ControllerIndex;

    ASSERT((&Input->Controllers[0].u.buttons.Terminator -
            &Input->Controllers[0].u.Buttons[0]) ==
                              ARRAY_SIZE(Input->Controllers[0].u.Buttons));
    ASSERT(sizeof(game_state) <= Memory->PermanentStorageSize);

    GameState = (game_state *)Memory->PermanentStorage;
    if(!Memory->IsInitialized) {
#if BUILD_INTERNAL
        char *FileName;
        debug_read_file_result BitmapMemory;

        FileName = "/home/igor/Developer/handmade/sdl_handmade.cpp";
        BitmapMemory = Memory->DEBUGPlatformReadEntireFile(Thread, FileName);
        if(BitmapMemory.Contents) {
            Memory->DEBUGPlatformWriteEntireFile(Thread, "test.out",
                                                 BitmapMemory.ContentsSize,
                                                 BitmapMemory.Contents);
            Memory->DEBUGPlatformFreeFileMemory(Thread,
                                                BitmapMemory.Contents);
        }
#endif

        GameState->ToneHz = 256;
        GameState->tSine = 0.0f;

        /* TODO: Maybe more appropriate to do in the platform layer? */
        Memory->IsInitialized = TRUE;
    }
    /* GameState.ToneHz; */
    /* GameState.GreenOffset; */
    /* GameState.BlueOffset; */

    for(ControllerIndex = 0;
        ControllerIndex < ARRAY_SIZE(Input->Controllers);
        ControllerIndex++)
    {
        game_controller_input *Controller =
            GetController(Input, ControllerIndex);
        if(Controller->IsAnalog) {
            GameState->GreenOffset +=
                (int)(4.0f*(Controller->StickAverageY));
            GameState->BlueOffset +=
                (int)(4.0f*(Controller->StickAverageX));
            GameState->ToneHz =
                256 + (S32)(128.0f*(Controller->StickAverageY));
        } else {
            if(Controller->u.buttons.MoveUp.EndedDown) {
                GameState->GreenOffset -= 5;
            }
            if(Controller->u.buttons.MoveDown.EndedDown) {
                GameState->GreenOffset += 5;
            }
            if(Controller->u.buttons.MoveLeft.EndedDown) {
                GameState->BlueOffset -= 5;
            }
            if(Controller->u.buttons.MoveRight.EndedDown) {
                GameState->BlueOffset += 5;
            }
        }
    }

    GameOutputSound(GameState, SoundBuffer, GameState->ToneHz);
    RenderWeirdGradient(Buffer, GameState->BlueOffset,
                        GameState->GreenOffset);
    {
        S32 i;
        for(i = 0; i < (S32)ARRAY_SIZE(Input->MouseButtons); i++) {
            if(Input->MouseButtons[i].EndedDown)
                RenderRectangle(Buffer, 10 + 20 * i, 10);
        }
    }

    RenderRectangle(Buffer, Input->MouseX, Input->MouseY);
}