#define SDL_MAIN_USE_CALLBACKS
#include <SDL3/SDL.h>
#include <SDL3/SDL_main.h>
#include <SDL3/SDL_properties.h>
#include <SDL3_image/SDL_image.h>
#include <SDL3_mixer/SDL_mixer.h>
#include <box2d/box2d.h>

#include "assets.h"
#include "iterator.h"
#include "tilemap.h"
#include "heap.h"
#include "game.h"
#include "gamepad.h"
#include "physics.h"
#include "draw.h"
#include "sprite.h"
#include "actor.h"
#include "error.h"
#include "registry.h"

SDL_AppResult SDL_AppInit(void **appstate, int argc, char *argv[])
{
    actor *actorptr = NULL;
    PREPARE_ERROR(errctx);
     
    SDL_AudioSpec spec;
    
    ATTEMPT {
	CATCH(errctx, heap_init());
	CATCH(errctx, registry_init_actor());
	CATCH(errctx, registry_init_sprite());
	CATCH(errctx, registry_init_spritesheet());
	CATCH(errctx, registry_init_character());
	FAIL_ZERO_BREAK(errctx, appstate, ERR_NULLPOINTER, "NULL appstate pointer");
    } CLEANUP {
    } PROCESS(errctx) {
    } HANDLE_DEFAULT(errctx) {
	LOG_ERROR(errctx);
	return SDL_APP_FAILURE;
    } FINISH_NORETURN(errctx);

    *appstate = (void *)&gamestate;
    
    SDL_SetAppMetadata("SDL3-GameTest", "0.1", "net.aklabs.sdl3-gametest");

    if (!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_GAMEPAD | SDL_INIT_AUDIO )) {
	SDL_Log("Couldn't initialize SDL: %s", SDL_GetError());
	return SDL_APP_FAILURE;
    }
  
    if (!SDL_CreateWindowAndRenderer("net/aklabs/sdl3-gametest", 640, 480, 0, &window, &renderer)) {
	SDL_Log("Couldn't create window/renderer: %s", SDL_GetError());
	return SDL_APP_FAILURE;
    }

    /*
      ATTEMPT {
      spritesheet *sheet;
      sprite *spr;
      character *basechar;
      CATCH(errctx, heap_next_spritesheet(&sheet));
      CATCH(errctx, spritesheet_initialize(sheet, 48, 48, "../assets/Actor1.png"));
	 
      CATCH(errctx, heap_next_sprite(&spr));
      CATCH(errctx, sprite_initialize(spr, "tester", sheet));
      spr->frameids[0] = 13;
      spr->speed = 100;
      spr->loop = false;
      spr->loopReverse = false;
      spr->width = 48;
      spr->height = 48;
	 
      CATCH(errctx, heap_next_character(&basechar));
      CATCH(errctx, character_initialize(basechar, "tester"));
      CATCH(errctx, character_sprite_add(basechar, spr, (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT)));
	       
      CATCH(errctx, heap_next_actor(&actorptr));
      CATCH(errctx, actor_initialize((actor *)actorptr, "player"));
      actorptr->basechar = basechar;
      actorptr->visible = true;
      actorptr->x = 120;
      actorptr->y = 120;
      actorptr->layer = 0;
      actorptr->state = (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT);
	 
      } CLEANUP {
      } PROCESS(errctx) {
      } FINISH_NORETURN(errctx);
     */
     
    GAME_init_physics();
  
    spec.freq = MIX_DEFAULT_FREQUENCY;
    spec.format = MIX_DEFAULT_FORMAT;
    spec.channels = MIX_DEFAULT_CHANNELS;
    if (!Mix_OpenAudio(0, &spec)) {
	SDL_Log("Couldn't initialize the audio subsystem: %s", SDL_GetError());
	return SDL_APP_FAILURE;
    } else {
	Mix_QuerySpec(&spec.freq, &spec.format, &spec.channels);
	SDL_Log("Opened audio at %d Hz %d bit%s %s audio buffer\n", spec.freq,
		(spec.format&0xFF),
		(SDL_AUDIO_ISFLOAT(spec.format) ? " (float)" : ""),
		(spec.channels > 2) ? "surround" : (spec.channels > 1) ? "stereo" : "mono");
    }

    ATTEMPT {
	CATCH(errctx, sprite_load_json("../assets/sprites/little_guy_walking_left.json"));
	CATCH(errctx, sprite_load_json("../assets/sprites/little_guy_facing_left.json"));
	CATCH(errctx, character_load_json("../assets/characters/littleguy.json"));    
	CATCH(errctx, heap_next_actor(&actorptr));
	CATCH(errctx, actor_initialize((actor *)actorptr, "player"));
	actorptr->basechar = SDL_GetPointerProperty(
	    REGISTRY_CHARACTER,
	    "little guy",
	    NULL);
	FAIL_ZERO_BREAK(errctx, actorptr->basechar, ERR_REGISTRY, "Can't load character 'little guy' from the registry");
    } CLEANUP {
    } PROCESS(errctx) {
    } HANDLE(errctx, ERR_NULLPOINTER) {
	SDL_Log("Attempting to load asset: %s (%s)", errctx->message, SDL_GetError());
	return SDL_APP_FAILURE;
    } FINISH_NORETURN(errctx);

    actorptr->movementspeed = 100;
    actorptr->state = (ACTOR_STATE_ALIVE | ACTOR_STATE_FACE_LEFT | ACTOR_STATE_MOVING_LEFT);
    actorptr->x = 320;
    actorptr->y = 240;
    actorptr->visible = true;

    ATTEMPT {
	//load_start_bgm("../assets/nutcracker.mid");
	CATCH(errctx, load_start_bgm("../assets/memories.mp3"));
    } CLEANUP {
    } PROCESS(errctx) {
    } HANDLE(errctx, ERR_NULLPOINTER) {
    } HANDLE_GROUP(errctx, ERR_SDL) {
	LOG_ERROR(errctx);
	return SDL_APP_FAILURE;
    } FINISH_NORETURN(errctx);

     
    ATTEMPT {
	CATCH(errctx, tilemap_load("../assets/tilemap.tmj", (tilemap *)&gamemap));
    } CLEANUP {
    } PROCESS(errctx) {
    } HANDLE_DEFAULT(errctx) {
	SDL_Log("Error while loading tilemap: %s", SDL_GetError());
	return SDL_APP_FAILURE;
    } FINISH_NORETURN(errctx);
     
     
    camera.x = 0;
    camera.y = 0;
    camera.w = 640;
    camera.h = 480;
  
    return SDL_APP_CONTINUE;
}

SDL_AppResult SDL_AppEvent(void *appstate, SDL_Event *event)
{
    PREPARE_ERROR(errctx);

    ATTEMPT {
	FAIL_ZERO_BREAK(errctx, appstate, ERR_NULLPOINTER, "NULL appstate pointer");
	FAIL_ZERO_BREAK(errctx, event, ERR_NULLPOINTER, "NULL event pointer");
	
	if (event->type == SDL_EVENT_QUIT) {
	    return SDL_APP_SUCCESS;  /* end the program, reporting success to the OS. */
	} else if (event->type == SDL_EVENT_GAMEPAD_BUTTON_DOWN) {
	    CATCH(errctx, gamepad_handle_button_down(appstate, event));
	} else if ( event->type == SDL_EVENT_GAMEPAD_BUTTON_UP) {
	    CATCH(errctx, gamepad_handle_button_up(appstate, event));
	} else if (event->type == SDL_EVENT_GAMEPAD_ADDED) {
	    CATCH(errctx, gamepad_handle_added(appstate, event));
	} else if (event->type == SDL_EVENT_GAMEPAD_REMOVED) {
	    CATCH(errctx, gamepad_handle_removed(appstate, event));
	}
    } CLEANUP {
    } PROCESS(errctx) {
    } FINISH_NORETURN(errctx);
    return SDL_APP_CONTINUE;  /* carry on with the program! */
}

SDL_AppResult SDL_AppIterate(void *appstate)
{
    //SDL_FRect dest;
    //b2Vec2 position;
    int i = 0;
    iterator opflags;

    PREPARE_ERROR(errctx);
    
    BITMASK_CLEAR(opflags.flags);
    BITMASK_ADD(opflags.flags, ITERATOR_OP_UPDATE);
    BITMASK_ADD(opflags.flags, ITERATOR_OP_RENDER);
    BITMASK_ADD(opflags.flags, ITERATOR_OP_LAYERMASK);
  
    for ( i = 0; i < TILEMAP_MAX_LAYERS; i++ ) {
	opflags.layerid = i;
	ATTEMPT {
	    CATCH(errctx, tilemap_draw(renderer, (tilemap *)&gamemap, &camera, i));
	    SDL_EnumerateProperties(REGISTRY_ACTOR, &registry_iterate_actor, (void *)&opflags);
	} CLEANUP {
	} PROCESS(errctx) {
	} HANDLE_DEFAULT(errctx) {
	    LOG_ERROR(errctx);
	    return SDL_APP_FAILURE;
	} FINISH_NORETURN(errctx);
    }
    SDL_RenderPresent(renderer);
    return SDL_APP_CONTINUE;
}

void SDL_AppQuit(void *appstate, SDL_AppResult result)
{
    /* SDL will clean up the window/renderer for us. */
    SDL_DestroyTexture(ball.texture);
    b2DestroyWorld(physicsWorldId);
    SDL_Log("Freeing music resources");
    if ( bgm != NULL ) {
	Mix_FreeMusic(bgm);
    }
    SDL_Log("Quitting mixer");
    Mix_Quit();
}