// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at

//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "esp32-hal-timer.h"

#if SOC_GPTIMER_SUPPORTED
#include "driver/gptimer.h"
#if defined __has_include && __has_include ("clk_tree.h")
#include "clk_tree.h"
#else
#include "esp_clk_tree.h"
#endif

typedef void (*voidFuncPtr)(void);
typedef void (*voidFuncPtrArg)(void*);

typedef struct {
    voidFuncPtr fn;
    void* arg;
} interrupt_config_t;

struct timer_struct_t {
    gptimer_handle_t timer_handle;
    interrupt_config_t interrupt_handle;
    bool timer_started;
};

inline uint64_t timerRead(hw_timer_t * timer){

    uint64_t value;
    gptimer_get_raw_count(timer->timer_handle, &value);
    return value;
}

void timerWrite(hw_timer_t * timer, uint64_t val){
    gptimer_set_raw_count(timer->timer_handle, val);
}

void timerAlarm(hw_timer_t * timer, uint64_t alarm_value, bool autoreload, uint64_t reload_count){
    esp_err_t err = ESP_OK;
    gptimer_alarm_config_t alarm_cfg = {
        .alarm_count = alarm_value,
        .reload_count = reload_count,
        .flags.auto_reload_on_alarm = autoreload,
    };
    err = gptimer_set_alarm_action(timer->timer_handle, &alarm_cfg);
    if (err != ESP_OK){
        log_e("Timer Alarm Write failed, error num=%d", err);
    } 
}

uint32_t timerGetFrequency(hw_timer_t * timer){
    uint32_t frequency;
    gptimer_get_resolution(timer->timer_handle, &frequency);
    return frequency;
}

void timerStart(hw_timer_t * timer){
    gptimer_start(timer->timer_handle);
    timer->timer_started = true;
}

void timerStop(hw_timer_t * timer){
    gptimer_stop(timer->timer_handle);
    timer->timer_started = false;
}

void timerRestart(hw_timer_t * timer){
    gptimer_set_raw_count(timer->timer_handle,0);
}

hw_timer_t * timerBegin(uint32_t frequency){
    esp_err_t err = ESP_OK;
    uint32_t counter_src_hz = 0;
    uint32_t divider = 0;
    soc_periph_gptimer_clk_src_t clk;

    soc_periph_gptimer_clk_src_t gptimer_clks[] = SOC_GPTIMER_CLKS;
    for (size_t i = 0; i < sizeof(gptimer_clks) / sizeof(gptimer_clks[0]); i++){
        clk = gptimer_clks[i];
#if defined __has_include && __has_include ("clk_tree.h")
        clk_tree_src_get_freq_hz(clk, CLK_TREE_SRC_FREQ_PRECISION_CACHED, &counter_src_hz);
#else
        esp_clk_tree_src_get_freq_hz(clk, ESP_CLK_TREE_SRC_FREQ_PRECISION_CACHED, &counter_src_hz);
#endif
        divider = counter_src_hz / frequency;
        if((divider >= 2) && (divider <= 65536)){
            break;
        }
        else divider = 0;
    }

    if(divider == 0){
        log_e("Resolution cannot be reached with any clock source, aborting!");
        return NULL;
    }

    gptimer_config_t config = {
            .clk_src = clk,
            .direction = GPTIMER_COUNT_UP,
            .resolution_hz = frequency,
            .flags.intr_shared = true,
        };

    hw_timer_t *timer = malloc(sizeof(hw_timer_t));

    err = gptimer_new_timer(&config, &timer->timer_handle);
    if (err != ESP_OK){
        log_e("Failed to create a new GPTimer, error num=%d", err);
        free(timer);
        return NULL;
    } 
    gptimer_enable(timer->timer_handle);
    gptimer_start(timer->timer_handle);
    timer->timer_started = true;
    return timer;
}

void timerEnd(hw_timer_t * timer){
    esp_err_t err = ESP_OK;
    if(timer->timer_started == true){
        gptimer_stop(timer->timer_handle);
    }
    gptimer_disable(timer->timer_handle);
    err = gptimer_del_timer(timer->timer_handle);
    if (err != ESP_OK){
        log_e("Failed to destroy GPTimer, error num=%d", err);
        return;
    }
    free(timer);
}

bool IRAM_ATTR timerFnWrapper(gptimer_handle_t timer, const gptimer_alarm_event_data_t *edata, void * args){
    interrupt_config_t * isr = (interrupt_config_t*)args;
    if(isr->fn) {
        if(isr->arg){
            ((voidFuncPtrArg)isr->fn)(isr->arg);
        } else {
            isr->fn();
        }
    }
    // some additional logic or handling may be required here to approriately yield or not
    return false;
}

void timerAttachInterruptFunctionalArg(hw_timer_t * timer, void (*userFunc)(void*), void * arg){
    esp_err_t err = ESP_OK;
    gptimer_event_callbacks_t cbs = {
        .on_alarm = timerFnWrapper,
    };

    timer->interrupt_handle.fn = (voidFuncPtr)userFunc;
    timer->interrupt_handle.arg = arg;

    if(timer->timer_started == true){
        gptimer_stop(timer->timer_handle);
    }
    gptimer_disable(timer->timer_handle);
    err = gptimer_register_event_callbacks(timer->timer_handle, &cbs, &timer->interrupt_handle);
    if (err != ESP_OK){
        log_e("Timer Attach Interrupt failed, error num=%d", err);
    } 
    gptimer_enable(timer->timer_handle);
    if(timer->timer_started == true){
        gptimer_start(timer->timer_handle);
    }

}

void timerAttachInterruptArg(hw_timer_t * timer, void (*userFunc)(void*), void * arg){
    timerAttachInterruptFunctionalArg(timer, userFunc, arg);
}

void timerAttachInterrupt(hw_timer_t * timer, voidFuncPtr userFunc){
    timerAttachInterruptFunctionalArg(timer, (voidFuncPtrArg)userFunc, NULL);
}

void timerDetachInterrupt(hw_timer_t * timer){
    esp_err_t err = ESP_OK;
    err = gptimer_set_alarm_action(timer->timer_handle, NULL);
    timer->interrupt_handle.fn = NULL;
    timer->interrupt_handle.arg = NULL;
    if (err != ESP_OK){
        log_e("Timer Detach Interrupt failed, error num=%d", err);
    } 
}

uint64_t timerReadMicros(hw_timer_t * timer){
    uint64_t timer_val = timerRead(timer);
    uint32_t frequency = timerGetFrequency(timer);
    return timer_val * 1000000 / frequency;
}

uint64_t timerReadMilis(hw_timer_t * timer){
    uint64_t timer_val = timerRead(timer);
    uint32_t frequency = timerGetFrequency(timer);
    return timer_val * 1000 / frequency;
}

double timerReadSeconds(hw_timer_t * timer){
    uint64_t timer_val = timerRead(timer);
    uint32_t frequency = timerGetFrequency(timer);
    return (double)timer_val / frequency;
}

#endif /* SOC_GPTIMER_SUPPORTED */
