#include QMK_KEYBOARD_H

// Declarations for inactivity tracking
#define INACTIVITY_STEPS {0, 100, 60000, 20, 300000, 0}
#define TIME_TO_CHANGE_BETWEEN_STEPS 10000
uint32_t activity_timer;

bool is_led_dimmed = 0;

float led_edge_brightness_pre_dim;
float led_gcr_desired_pre_dim;

void handle_activity(void);
void handle_inactivity(void);

void reset_after_inactivity(void);
void update_during_inactivity(void);

float get_desired_percentage(void);
float get_desired_gcr_desired(void);
float get_desired_led_edge_brightness(void);

void update_activity_timer(void);
uint32_t get_inactive_time(void);

void led_increase_key_brightness(void);
void led_increase_edge_brightness(void);
void led_decrease_key_brightness(void);
void led_decrease_edge_brightness(void);

// Inactivity tracking
void handle_activity(void) {
    update_activity_timer();

    if (is_led_dimmed) {
        reset_after_inactivity();
    }
}

void handle_inactivity(void) {
    if (!is_led_dimmed) {
        led_edge_brightness_pre_dim = led_edge_brightness;
        led_gcr_desired_pre_dim = gcr_desired;
    }

    update_during_inactivity();
}

void reset_after_inactivity(void) {
    gcr_desired = led_gcr_desired_pre_dim;
    led_edge_brightness = led_edge_brightness_pre_dim;

    is_led_dimmed = 0;
}

void update_during_inactivity(void) {
    float desired_gcr_desired = get_desired_gcr_desired();
    float desired_led_edge_brightness = get_desired_led_edge_brightness();

    if (!is_led_dimmed && (desired_gcr_desired < led_gcr_desired_pre_dim || desired_led_edge_brightness < led_edge_brightness_pre_dim)) {
        is_led_dimmed = 1;
    }

    if (desired_led_edge_brightness < led_edge_brightness) {
        led_decrease_edge_brightness();
    }

    if (desired_gcr_desired < gcr_desired) {
        led_decrease_key_brightness();
    }
}

float get_desired_percentage(void) {
    static int steps[] = INACTIVITY_STEPS;
    static int size = sizeof steps / sizeof steps[0];

    uint32_t inactive_time = get_inactive_time();

    int last_target = steps[1];
    int time_offset = steps[0];
    int target = steps[1];

    for (int i = 2; i < size; i += 2) {
        if (steps[i] > inactive_time) {
            break;
        }

        last_target = target;

        time_offset = steps[i];
        target = steps[i+1];
    }

    uint32_t time_into_current_target = inactive_time - time_offset;

    time_into_current_target = time_into_current_target > TIME_TO_CHANGE_BETWEEN_STEPS ? TIME_TO_CHANGE_BETWEEN_STEPS : time_into_current_target;
    time_into_current_target = time_into_current_target < 0 ? 0 : time_into_current_target;

    return (float)last_target + ((float)time_into_current_target / (float)TIME_TO_CHANGE_BETWEEN_STEPS) * (float)(target - last_target);
}

float get_desired_gcr_desired(void) {
    float pct = get_desired_percentage();

    return pct * LED_GCR_MAX / 100;
}

float get_desired_led_edge_brightness(void) {
    float pct = get_desired_percentage();

    return pct / 100;
}

void update_activity_timer(void) {
    activity_timer = timer_read32();
}

uint32_t get_inactive_time(void) {
    return timer_read32() - activity_timer;
}

// Lighting stuff for inactivity tracking
// Increase
void led_increase_key_brightness(void) {
    if (LED_GCR_STEP > LED_GCR_MAX - gcr_desired) gcr_desired = LED_GCR_MAX;
    else gcr_desired += LED_GCR_STEP;
    if (led_animation_breathing) gcr_breathe = gcr_desired;
}

void led_increase_edge_brightness(void) {
    led_edge_brightness += 0.1;
    if (led_edge_brightness > 1) { led_edge_brightness = 1; }
}

// Decrease
void led_decrease_key_brightness(void) {
    if (LED_GCR_STEP > gcr_desired) gcr_desired = 0;
    else gcr_desired -= LED_GCR_STEP;
    if (led_animation_breathing) gcr_breathe = gcr_desired;
}

void led_decrease_edge_brightness(void) {
    led_edge_brightness -= 0.1;
    if (led_edge_brightness < 0) { led_edge_brightness = 0; }
}