#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "stm32c0xx_hal.h"
#include <stdio.h>

ADC_HandleTypeDef hadc;
UART_HandleTypeDef huart;

QueueHandle_t sensorQueue;
SemaphoreHandle_t emergencySemaphore;
SemaphoreHandle_t thresholdMutex;

uint16_t humidityThreshold = 2000; // Valeur initiale arbitraire

typedef struct {
    int zone;
    uint16_t value;
} SensorData;

void sendUART(const char* message) {
    HAL_UART_Transmit(&huart, (uint8_t*)message, strlen(message), HAL_MAX_DELAY);
}

uint16_t readADC(uint32_t channel) {
    ADC_ChannelConfTypeDef sConfig = {0};
    sConfig.Channel = channel;
    sConfig.Rank = ADC_REGULAR_RANK_1;
    HAL_ADC_ConfigChannel(&hadc, &sConfig);
    HAL_ADC_Start(&hadc);
    HAL_ADC_PollForConversion(&hadc, HAL_MAX_DELAY);
    return HAL_ADC_GetValue(&hadc);
}

// Tâche de lecture des capteurs (PA0, PA1)
void Task_ReadHumidity(void* params) {
    SensorData data;
    while (1) {
        for (int i = 0; i < 2; i++) {
            data.zone = i;
            data.value = readADC(i == 0 ? ADC_CHANNEL_0 : ADC_CHANNEL_1);

            xSemaphoreTake(thresholdMutex, portMAX_DELAY);
            uint16_t localThreshold = humidityThreshold;
            xSemaphoreGive(thresholdMutex);

            if (data.value < localThreshold) {
                xQueueSend(sensorQueue, &data, portMAX_DELAY);
            }

            char msg[64];
            sprintf(msg, "Capteur Zone %d: %d\n", i + 1, data.value);
            sendUART(msg);
        }
        vTaskDelay(pdMS_TO_TICKS(5000));
    }
}

// Tâche d’arrosage
void Task_WateringControl(void* params) {
    SensorData received;
    while (1) {
        if (xQueueReceive(sensorQueue, &received, portMAX_DELAY) == pdPASS) {
            if (xSemaphoreTake(emergencySemaphore, 0) == pdPASS) continue;

            int ledPin = received.zone == 0 ? GPIO_PIN_4 : GPIO_PIN_5;
            HAL_GPIO_WritePin(GPIOA, ledPin, GPIO_PIN_SET);

            char msg[64];
            sprintf(msg, "Vanne %d activée\n", received.zone + 1);
            sendUART(msg);

            vTaskDelay(pdMS_TO_TICKS(10000)); // 10 sec

            HAL_GPIO_WritePin(GPIOA, ledPin, GPIO_PIN_RESET);
            sprintf(msg, "Vanne %d désactivée\n", received.zone + 1);
            sendUART(msg);
        }
    }
}

// Tâche d’urgence
void Task_Emergency(void* params) {
    while (1) {
        if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_3) == GPIO_PIN_SET) {
            sendUART("** Arrêt d'urgence déclenché **\n");
            HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4 | GPIO_PIN_5, GPIO_PIN_RESET);
            HAL_GPIO_WritePin(GPIOA, GPIO_PIN_6, GPIO_PIN_SET);
            xSemaphoreGive(emergencySemaphore);
            vTaskDelay(pdMS_TO_TICKS(2000)); // Anti-rebond
        }
        vTaskDelay(pdMS_TO_TICKS(200));
    }
}

// Tâche de mise à jour du seuil
void Task_UpdateThreshold(void* params) {
    while (1) {
        uint16_t newValue = readADC(ADC_CHANNEL_2);
        xSemaphoreTake(thresholdMutex, portMAX_DELAY);
        humidityThreshold = newValue;
        xSemaphoreGive(thresholdMutex);

        char msg[64];
        sprintf(msg, "Nouveau seuil humidité : %d\n", newValue);
        sendUART(msg);

        vTaskDelay(pdMS_TO_TICKS(2000));
    }
}

void SystemClock_Config(void);
void MX_GPIO_Init(void);
void MX_ADC_Init(void);
void MX_USART_Init(void);

int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_ADC_Init();
    MX_USART_Init();

    sensorQueue = xQueueCreate(10, sizeof(SensorData));
    emergencySemaphore = xSemaphoreCreateBinary();
    thresholdMutex = xSemaphoreCreateMutex();

    xTaskCreate(Task_ReadHumidity, "ReadHumidity", 128, NULL, 2, NULL);
    xTaskCreate(Task_WateringControl, "Watering", 128, NULL, 2, NULL);
    xTaskCreate(Task_Emergency, "Emergency", 128, NULL, 3, NULL);
    xTaskCreate(Task_UpdateThreshold, "Threshold", 128, NULL, 1, NULL);

    vTaskStartScheduler();
    while (1) {}
}

// À adapter selon le simulateur Wokwi (ou init CubeMX pour vrai projet)
void MX_GPIO_Init(void) {
    __HAL_RCC_GPIOA_CLK_ENABLE();
    GPIO_InitTypeDef GPIO_InitStruct = {0};

    // LED vanne
    GPIO_InitStruct.Pin = GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

    // Bouton
    GPIO_InitStruct.Pin = GPIO_PIN_3;
    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}

void MX_ADC_Init(void) {
    __HAL_RCC_ADC_CLK_ENABLE();
    hadc.Instance = ADC1;
    hadc.Init.Resolution = ADC_RESOLUTION_12B;
    hadc.Init.ContinuousConvMode = DISABLE;
    hadc.Init.ScanConvMode = ADC_SCAN_DISABLE;
    HAL_ADC_Init(&hadc);
}

void MX_USART_Init(void) {
    __HAL_RCC_USART2_CLK_ENABLE();
    huart.Instance = USART2;
    huart.Init.BaudRate = 9600;
    huart.Init.WordLength = UART_WORDLENGTH_8B;
    huart.Init.StopBits = UART_STOPBITS_1;
    huart.Init.Parity = UART_PARITY_NONE;
    huart.Init.Mode = UART_MODE_TX_RX;
    huart.Init.HwFlowCtl = UART_HWCONTROL_NONE;
    HAL_UART_Init(&huart);
}