#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#include "hexgame.h"
#include "hexgame_state.h"
#include "anim.h"
#include "hexmap.h"
#include "hexspace.h"
#include "prismelrenderer.h"
#include "array.h"
#include "util.h"
#include "hexgame_vars_props.h"



void actor_cleanup(actor_t *actor){
    vars_cleanup(&actor->vars);
}

int actor_init(actor_t *actor, hexmap_t *map, body_t *body,
    const char *stateset_filename, const char *state_name,
    trf_t *trf
){
    int err;

    memset(actor, 0, sizeof(*actor));

    vars_init_with_props(&actor->vars, hexgame_vars_prop_names);

    if(trf)actor->trf = *trf;

    /* NOTE: body may be NULL */
    actor->body = body;

    actor->game = map->game;

    err = actor_init_stateset(actor, stateset_filename, state_name, map);
    if(err)return err;

    return 0;
}


int actor_get_index(actor_t *actor){
    hexgame_t *game = actor->game;
    for(int i = 0; i < game->actors_len; i++){
        actor_t *_actor = game->actors[i];
        if(actor == _actor)return i;
    }
    return -1;
}

int actor_init_stateset(actor_t *actor, const char *stateset_filename,
    const char *state_name, hexmap_t *map
){
    int err;

    err = hexgame_get_or_load_stateset(actor->game, stateset_filename,
        &actor->stateset);
    if(err)return err;

    if(state_name == NULL){
        state_name = actor->stateset->default_state_name;
    }

    err = actor_set_state(actor, state_name);
    if(err)return err;

    return 0;
}

int actor_set_state(actor_t *actor, const char *state_name){
    if(state_name == NULL){
        actor->state = NULL;
    }else{
        actor->state = stateset_get_state(actor->stateset, state_name);
        if(actor->state == NULL){
            fprintf(stderr, "Couldn't init actor stateset: "
                "couldn't find state %s in stateset %s\n",
                state_name, actor->stateset->filename);
            return 2;}
    }
    return 0;
}

int actor_handle_rules(actor_t *actor, body_t *your_body){
    int err;
    hexgame_state_context_t context = {
        .game = actor->game,
        .actor = actor,
        .body = actor->body,
        .your_body = your_body,
    };
    handle: {
        if(hexgame_state_context_debug(&context)){
            fprintf(stderr, "Handling rules for state: \"%s\" -> \"%s\"\n",
                actor->state->stateset->filename, actor->state->name);
        }
        state_effect_goto_t *gotto = NULL;
        err = state_handle_rules(actor->state, &context, &gotto);
        if(err)return err;
        if(gotto != NULL){
            err = state_effect_goto_apply_to_actor(gotto, actor);
            if(err)return err;

            if(gotto->immediate)goto handle;
                /* If there was an "immediate goto" effect,
                then we immediately handle the new state's rules */
        }
    }
    return 0;
}

int actor_step(actor_t *actor, struct hexgame *game){
    int err;

    if(actor->wait > 0){
        actor->wait--;
        return 0;
    }

    body_t *body = actor->body;
    if(body == NULL || (
        body->recording.action != RECORDING_ACTION_PLAY &&
        body->cooldown == 0
    )){
        /* Handle current state's rules */
        err = actor_handle_rules(actor, NULL);
        if(err)return err;
    }
    return 0;
}

int actor_refresh_vars(actor_t *actor){
    int err;
    vars_t *vars = &actor->vars;

    /* At the moment, actor doesn't set any special vars... */

    return 0;
}