#include "chick.h"

#include <debug.h>
#include <graphx.h>
#include <string.h>
#include <tice.h>

#include "colors.h"
#include "gfx/gfx.h"

void init_chick(struct chick *chick) {
    chick->quote = NULL;
    chick->x = randInt(2 * chicken_width, LCD_WIDTH - 2 * chicken_width);
    chick->dir = randInt(0, 1);
    chick->standing = randInt(0, 1);
    chick->current_leg = randInt(0, 1);
    chick->anim_frame = randInt(0, 255);
}

const struct {
    const char *str;
    uint8_t weight;
} chick_quote_strings[] = {
    {"quack", 6},
    {"moo", 1},
    {"Doors CE when?", 2},
    {"they'll never believe you", 1},
    {"cluck", 80},
};

const char *get_quote(void) {
    if(!randInt(0, 7)) {
        
        uint8_t total = 6 + 1 + 2 + 1 + 80;

        int8_t n = randInt(0, total - 1);
        uint8_t i = 0;
        while(n >= 0 && i <= 5) {
            n -= chick_quote_strings[i].weight;
            i++;
        }
        return chick_quote_strings[i - 1].str;
    }
    return NULL;
}

void update_chick(struct chick *out, const struct chick *in) {
    out->anim_frame = in->anim_frame + 1;
    out->x = in->x;
    out->dir = in->dir;
    out->standing = in->standing;
    out->current_leg = in->current_leg;
    out->quote = in->quote;

    if(!out->standing && out->anim_frame % 2 == 0) {
        if(out->dir == LEFT) out->x -= 1;
        else out->x += 1;
    }
    if(out->anim_frame % 16 == 0) {
        out->current_leg = !out->current_leg;
    }

    if(out->anim_frame == 255) {
        out->standing = randInt(0, 1);
        out->dir = randInt(0, 1);
        out->quote = get_quote();
    }

    if(out->anim_frame == 4) {
        out->quote = NULL;
    }

    // Keep chickens in bounds
    if(out->x > LCD_WIDTH * 5/6) {
        out->dir = LEFT;
        out->x--;
    }
    if(out->x < LCD_WIDTH * 1/6) {
        out->dir = RIGHT;
        out->x++;
    }
}

#define CHICKEN_BASE_Y (LCD_HEIGHT * 5/6 + 10 - chicken_height)

#define LEFT_LEG_Y (CHICKEN_BASE_Y + LEFT_LEG_Y_OFFSET)
#define RIGHT_LEG_Y (CHICKEN_BASE_Y + RIGHT_LEG_Y_OFFSET)

gfx_UninitedSprite(chicken_flipped, chicken_width, chicken_height);
gfx_UninitedSprite(left_leg_flipped, left_leg_width, left_leg_height);
gfx_UninitedSprite(right_leg_flipped, right_leg_width, right_leg_height);

gfx_UninitedSprite(large_chicken, LARGE_CHICKEN_WIDTH, LARGE_CHICKEN_HEIGHT);
gfx_UninitedSprite(chicken_square, chicken_height, chicken_height);

void draw_chick(const struct chick *chick) {
    uint8_t left_leg_y = LEFT_LEG_Y;
    if(!chick->standing && chick->current_leg == LEFT) left_leg_y -= 4;
    uint8_t right_leg_y = RIGHT_LEG_Y;
    if(!chick->standing && chick->current_leg == RIGHT) right_leg_y -= 4;
    if(chick->dir == LEFT) {
        gfx_TransparentSprite(left_leg, chick->x + LEFT_LEG_X_OFFSET, left_leg_y);
        gfx_TransparentSprite(right_leg, chick->x + RIGHT_LEG_X_OFFSET, right_leg_y);
        gfx_TransparentSprite(chicken, chick->x, CHICKEN_BASE_Y);
    } else {
        uint24_t left_leg_x = chick->x + chicken_width - LEFT_LEG_X_OFFSET - left_leg_width;
        gfx_TransparentSprite(left_leg_flipped, left_leg_x, left_leg_y);
        uint24_t right_leg_x = chick->x + chicken_width - RIGHT_LEG_X_OFFSET - right_leg_width;
        gfx_TransparentSprite(right_leg_flipped, right_leg_x, right_leg_y);
        gfx_TransparentSprite(chicken_flipped, chick->x, CHICKEN_BASE_Y);
    }

    if(chick->quote != NULL) {
        gfx_SetTextFGColor(WHITE);
        uint24_t x = chick->x + chicken_width / 2 - gfx_GetStringWidth(chick->quote) / 2;
        gfx_PrintStringXY(chick->quote, x, CHICKEN_BASE_Y - 10);
    }
}

void init_chick_sprites(void) {
    gfx_FlipSpriteY(chicken, chicken_flipped);
    gfx_FlipSpriteY(left_leg, left_leg_flipped);
    gfx_FlipSpriteY(right_leg, right_leg_flipped);

    gfx_SetColor(BLACK);
    gfx_FillRectangle_NoClip(0, 0, LARGE_CHICKEN_WIDTH, LARGE_CHICKEN_HEIGHT);
    gfx_ScaledTransparentSprite_NoClip(chicken, 0, 0, LARGE_CHICKEN_SCALE, LARGE_CHICKEN_SCALE);
    gfx_ScaledTransparentSprite_NoClip(left_leg,
                            LEFT_LEG_X_OFFSET * LARGE_CHICKEN_SCALE,
                            LEFT_LEG_Y_OFFSET * LARGE_CHICKEN_SCALE,
                            LARGE_CHICKEN_SCALE, LARGE_CHICKEN_SCALE);
    gfx_ScaledTransparentSprite_NoClip(right_leg,
                            RIGHT_LEG_X_OFFSET * LARGE_CHICKEN_SCALE,
                            RIGHT_LEG_Y_OFFSET * LARGE_CHICKEN_SCALE,
                            LARGE_CHICKEN_SCALE, LARGE_CHICKEN_SCALE);
    large_chicken->width = LARGE_CHICKEN_WIDTH;
    large_chicken->height = LARGE_CHICKEN_HEIGHT;
    gfx_GetSprite(large_chicken, 0, 0);
    gfx_FillScreen(BLACK);

    chicken_square->height = chicken_square->width = chicken_height;
    memset(chicken_square->data, 0, chicken_height * chicken_height);
    for(uint8_t y = 0; y < chicken_height; y++) {
        memcpy(&chicken_square->data[y * chicken_height + (chicken_height - chicken_width) / 2],
            &chicken->data[y * chicken_width], chicken_width);
    }
}